Use schema generated event classes for bookmarks API.

Converts bookmarks and bookmarkManagerPrivate event related functions
to use the schema generated classes instead of manually constructing
JSON objects.

BUG=

Review URL: https://codereview.chromium.org/185293019

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@255290 0039d316-1c4b-4281-b951-d872f2087c98

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

@@ -16,7 +16,6 @@
 #include "chrome/browser/bookmarks/bookmark_node_data.h"
 #include "chrome/browser/bookmarks/bookmark_stats.h"
 #include "chrome/browser/bookmarks/bookmark_utils.h"
-#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/extension_function_dispatcher.h"
@@ -54,7 +53,6 @@ namespace Copy = api::bookmark_manager_private::Copy;
 namespace Cut = api::bookmark_manager_private::Cut;
 namespace Drop = api::bookmark_manager_private::Drop;
 namespace GetSubtree = api::bookmark_manager_private::GetSubtree;
-namespace manager_keys = bookmark_manager_api_constants;
 namespace GetMetaInfo = api::bookmark_manager_private::GetMetaInfo;
 namespace Paste = api::bookmark_manager_private::Paste;
 namespace RedoInfo = api::bookmark_manager_private::GetRedoInfo;
@@ -97,74 +95,72 @@ bool GetNodesFromVector(BookmarkModel* model,
   return true;
 }
 
-// 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(base::ListValue* list, const BookmarkNode& node) {
-  base::DictionaryValue* dict = new base::DictionaryValue();
-
+// Recursively create a bookmark_manager_private::BookmarkNodeDataElement from
+// a bookmark node. 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.
+linked_ptr<bookmark_manager_private::BookmarkNodeDataElement>
+CreateNodeDataElementFromBookmarkNode(const BookmarkNode& node) {
+  linked_ptr<bookmark_manager_private::BookmarkNodeDataElement> element(
+      new bookmark_manager_private::BookmarkNodeDataElement);
   // 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(bookmark_keys::kIdKey, id_string);
-
-  std::string parent_id_string = base::Int64ToString(node.parent()->id());
-  dict->SetString(bookmark_keys::kParentIdKey, parent_id_string);
+  element->id.reset(new std::string(base::Int64ToString(node.id())));
+  element->parent_id.reset(
+      new std::string(base::Int64ToString(node.parent()->id())));
 
   if (node.is_url())
-    dict->SetString(bookmark_keys::kUrlKey, node.url().spec());
-
-  dict->SetString(bookmark_keys::kTitleKey, node.GetTitle());
+    element->url.reset(new std::string(node.url().spec()));
 
-  base::ListValue* children = new base::ListValue();
-  for (int i = 0; i < node.child_count(); ++i)
-    AddNodeToList(children, *node.GetChild(i));
-  dict->Set(bookmark_keys::kChildrenKey, children);
+  element->title = base::UTF16ToUTF8(node.GetTitle());
+  for (int i = 0; i < node.child_count(); ++i) {
+    element->children.push_back(
+        CreateNodeDataElementFromBookmarkNode(*node.GetChild(i)));
+  }
 
-  list->Append(dict);
+  return element;
 }
 
-// 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(base::ListValue* list,
-                      const BookmarkNodeData::Element& element) {
-  base::DictionaryValue* dict = new base::DictionaryValue();
+// Recursively create a bookmark_manager_private::BookmarkNodeDataElement from
+// a BookmarkNodeData::Element. 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.
+linked_ptr<bookmark_manager_private::BookmarkNodeDataElement>
+CreateApiNodeDataElement(const BookmarkNodeData::Element& element) {
+  linked_ptr<bookmark_manager_private::BookmarkNodeDataElement> node_element(
+      new bookmark_manager_private::BookmarkNodeDataElement);
 
   if (element.is_url)
-    dict->SetString(bookmark_keys::kUrlKey, element.url.spec());
-
-  dict->SetString(bookmark_keys::kTitleKey, element.title);
-
-  base::ListValue* children = new base::ListValue();
-  for (size_t i = 0; i < element.children.size(); ++i)
-    AddElementToList(children, element.children[i]);
-  dict->Set(bookmark_keys::kChildrenKey, children);
+    node_element->url.reset(new std::string(element.url.spec()));
+  node_element->title = base::UTF16ToUTF8(element.title);
+  for (size_t i = 0; i < element.children.size(); ++i) {
+    node_element->children.push_back(
+        CreateApiNodeDataElement(element.children[i]));
+  }
 
-  list->Append(dict);
+  return node_element;
 }
 
-// Builds the JSON structure based on the BookmarksDragData.
-void BookmarkNodeDataToJSON(Profile* profile, const BookmarkNodeData& data,
-                            base::ListValue* args) {
-  bool same_profile = data.IsFromProfile(profile);
-  base::DictionaryValue* value = new base::DictionaryValue();
-  value->SetBoolean(manager_keys::kSameProfileKey, same_profile);
+// Creates a bookmark_manager_private::BookmarkNodeData from a BookmarkNodeData.
+scoped_ptr<bookmark_manager_private::BookmarkNodeData>
+CreateApiBookmarkNodeData(Profile* profile, const BookmarkNodeData& data) {
+  scoped_ptr<bookmark_manager_private::BookmarkNodeData> node_data(
+      new bookmark_manager_private::BookmarkNodeData);
+  node_data->same_profile = data.IsFromProfile(profile);
 
-  base::ListValue* list = new base::ListValue();
-  if (same_profile) {
+  if (node_data->same_profile) {
     std::vector<const BookmarkNode*> nodes = data.GetNodes(profile);
-    for (size_t i = 0; i < nodes.size(); ++i)
-      AddNodeToList(list, *nodes[i]);
+    for (size_t i = 0; i < nodes.size(); ++i) {
+      node_data->elements.push_back(
+          CreateNodeDataElementFromBookmarkNode(*nodes[i]));
+    }
   } else {
-    // We do not have an node IDs when the data comes from a different profile.
+    // We do not have a 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]);
+      node_data->elements.push_back(CreateApiNodeDataElement(elements[i]));
   }
-  value->Set(manager_keys::kElementsKey, list);
-
-  args->Append(value);
+  return node_data.Pass();
 }
 
 }  // namespace
@@ -196,20 +192,13 @@ void BookmarkManagerPrivateEventRouter::DispatchEvent(
   ExtensionSystem::Get(profile_)->event_router()->BroadcastEvent(event.Pass());
 }
 
-void BookmarkManagerPrivateEventRouter::DispatchDragEvent(
-    const BookmarkNodeData& data,
-    const std::string& event_name) {
-  if (data.size() == 0)
-    return;
-
-  scoped_ptr<base::ListValue> args(new base::ListValue());
-  BookmarkNodeDataToJSON(profile_, data, args.get());
-  DispatchEvent(event_name, args.Pass());
-}
-
 void BookmarkManagerPrivateEventRouter::OnDragEnter(
     const BookmarkNodeData& data) {
-  DispatchDragEvent(data, bookmark_manager_private::OnDragEnter::kEventName);
+  if (data.size() == 0)
+    return;
+  DispatchEvent(bookmark_manager_private::OnDragEnter::kEventName,
+                bookmark_manager_private::OnDragEnter::Create(
+                    *CreateApiBookmarkNodeData(profile_, data)));
 }
 
 void BookmarkManagerPrivateEventRouter::OnDragOver(
@@ -220,11 +209,19 @@ void BookmarkManagerPrivateEventRouter::OnDragOver(
 
 void BookmarkManagerPrivateEventRouter::OnDragLeave(
     const BookmarkNodeData& data) {
-  DispatchDragEvent(data, bookmark_manager_private::OnDragLeave::kEventName);
+  if (data.size() == 0)
+    return;
+  DispatchEvent(bookmark_manager_private::OnDragLeave::kEventName,
+                bookmark_manager_private::OnDragLeave::Create(
+                    *CreateApiBookmarkNodeData(profile_, data)));
 }
 
 void BookmarkManagerPrivateEventRouter::OnDrop(const BookmarkNodeData& data) {
-  DispatchDragEvent(data, bookmark_manager_private::OnDrop::kEventName);
+  if (data.size() == 0)
+    return;
+  DispatchEvent(bookmark_manager_private::OnDrop::kEventName,
+                bookmark_manager_private::OnDrop::Create(
+                    *CreateApiBookmarkNodeData(profile_, data)));
 
   // Make a copy that is owned by this instance.
   ClearBookmarkNodeData();

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

@@ -48,9 +48,6 @@ class BookmarkManagerPrivateEventRouter
   void DispatchEvent(const std::string& event_name,
                      scoped_ptr<base::ListValue> args);
 
-  void DispatchDragEvent(const BookmarkNodeData& data,
-                         const std::string& event_name);
-
   Profile* profile_;
   content::WebContents* web_contents_;
   BookmarkNodeData bookmark_drag_data_;

chrome/browser/extensions/api/bookmark_manager_private/bookmark_manager_private_api_constants.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/extensions/api/bookmark_manager_private/bookmark_manager_private_api_constants.h"
-
-namespace extensions {
-namespace bookmark_manager_api_constants {
-
-// Keys.
-const char kSameProfileKey[] = "sameProfile";
-const char kElementsKey[] = "elements";
-
-}  // namespace bookmark_manager_api_constants
-}  // namespace extensions

chrome/browser/extensions/api/bookmark_manager_private/bookmark_manager_private_api_constants.h

-// 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.
-
-#ifndef CHROME_BROWSER_EXTENSIONS_API_BOOKMARK_MANAGER_PRIVATE_BOOKMARK_MANAGER_PRIVATE_API_CONSTANTS_H_
-#define CHROME_BROWSER_EXTENSIONS_API_BOOKMARK_MANAGER_PRIVATE_BOOKMARK_MANAGER_PRIVATE_API_CONSTANTS_H_
-
-namespace extensions {
-namespace bookmark_manager_api_constants {
-
-// Keys.
-extern const char kSameProfileKey[];
-extern const char kElementsKey[];
-
-// Events.
-extern const char kOnBookmarkDragEnter[];
-extern const char kOnBookmarkDragLeave[];
-extern const char kOnBookmarkDrop[];
-
-}  // namespace bookmark_manager_api_constants
-}  // namespace extensions
-
-
-#endif  // CHROME_BROWSER_EXTENSIONS_API_BOOKMARK_MANAGER_PRIVATE_BOOKMARK_MANAGER_PRIVATE_API_CONSTANTS_H_

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

@@ -7,15 +7,9 @@
 namespace extensions {
 namespace bookmark_api_constants {
 
-const char kIdKey[] = "id";
-const char kIndexKey[] = "index";
 const char kParentIdKey[] = "parentId";
-const char kOldIndexKey[] = "oldIndex";
-const char kOldParentIdKey[] = "oldParentId";
 const char kUrlKey[] = "url";
 const char kTitleKey[] = "title";
-const char kChildrenKey[] = "children";
-const char kChildIdsKey[] = "childIds";
 
 const char kNoNodeError[] = "Can't find bookmark for id.";
 const char kNoParentError[] = "Can't find parent bookmark for id.";

chrome/browser/extensions/api/bookmarks/bookmark_api_constants.h

@@ -11,15 +11,9 @@ namespace extensions {
 namespace bookmark_api_constants {
 
 // Keys.
-extern const char kIdKey[];
-extern const char kIndexKey[];
 extern const char kParentIdKey[];
-extern const char kOldIndexKey[];
-extern const char kOldParentIdKey[];
 extern const char kUrlKey[];
 extern const char kTitleKey[];
-extern const char kChildrenKey[];
-extern const char kChildIdsKey[];
 
 // Errors.
 extern const char kNoNodeError[];
@@ -31,15 +25,6 @@ extern const char kInvalidUrlError[];
 extern const char kModifySpecialError[];
 extern const char kEditBookmarksDisabled[];
 
-// Events.
-extern const char kOnBookmarkCreated[];
-extern const char kOnBookmarkRemoved[];
-extern const char kOnBookmarkChanged[];
-extern const char kOnBookmarkMoved[];
-extern const char kOnBookmarkChildrenReordered[];
-extern const char kOnBookmarkImportBegan[];
-extern const char kOnBookmarkImportEnded[];
-
 }  // namespace bookmark_api_constants
 }  // namespace extensions
 

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

@@ -196,47 +196,40 @@ void BookmarkEventRouter::BookmarkNodeMoved(BookmarkModel* model,
                                             int old_index,
                                             const BookmarkNode* new_parent,
                                             int new_index) {
-  scoped_ptr<base::ListValue> args(new base::ListValue());
   const BookmarkNode* node = new_parent->GetChild(new_index);
-  args->Append(new base::StringValue(base::Int64ToString(node->id())));
-  base::DictionaryValue* object_args = new base::DictionaryValue();
-  object_args->SetString(keys::kParentIdKey,
-                         base::Int64ToString(new_parent->id()));
-  object_args->SetInteger(keys::kIndexKey, new_index);
-  object_args->SetString(keys::kOldParentIdKey,
-                         base::Int64ToString(old_parent->id()));
-  object_args->SetInteger(keys::kOldIndexKey, old_index);
-  args->Append(object_args);
-
-  DispatchEvent(bookmarks::OnMoved::kEventName, args.Pass());
+  bookmarks::OnMoved::MoveInfo move_info;
+  move_info.parent_id = base::Int64ToString(new_parent->id());
+  move_info.index = new_index;
+  move_info.old_parent_id = base::Int64ToString(old_parent->id());
+  move_info.old_index = old_index;
+
+  DispatchEvent(
+      bookmarks::OnMoved::kEventName,
+      bookmarks::OnMoved::Create(base::Int64ToString(node->id()), move_info));
 }
 
 void BookmarkEventRouter::BookmarkNodeAdded(BookmarkModel* model,
                                             const BookmarkNode* parent,
                                             int index) {
-  scoped_ptr<base::ListValue> args(new base::ListValue());
   const BookmarkNode* node = parent->GetChild(index);
-  args->Append(new base::StringValue(base::Int64ToString(node->id())));
   scoped_ptr<BookmarkTreeNode> tree_node(
       bookmark_api_helpers::GetBookmarkTreeNode(node, false, false));
-  args->Append(tree_node->ToValue().release());
-
-  DispatchEvent(bookmarks::OnCreated::kEventName, args.Pass());
+  DispatchEvent(bookmarks::OnCreated::kEventName,
+                bookmarks::OnCreated::Create(base::Int64ToString(node->id()),
+                                             *tree_node));
 }
 
 void BookmarkEventRouter::BookmarkNodeRemoved(BookmarkModel* model,
                                               const BookmarkNode* parent,
                                               int index,
                                               const BookmarkNode* node) {
-  scoped_ptr<base::ListValue> args(new base::ListValue());
-  args->Append(new base::StringValue(base::Int64ToString(node->id())));
-  base::DictionaryValue* object_args = new base::DictionaryValue();
-  object_args->SetString(keys::kParentIdKey,
-                         base::Int64ToString(parent->id()));
-  object_args->SetInteger(keys::kIndexKey, index);
-  args->Append(object_args);
-
-  DispatchEvent(bookmarks::OnRemoved::kEventName, args.Pass());
+  bookmarks::OnRemoved::RemoveInfo remove_info;
+  remove_info.parent_id = base::Int64ToString(parent->id());
+  remove_info.index = index;
+
+  DispatchEvent(bookmarks::OnRemoved::kEventName,
+                bookmarks::OnRemoved::Create(base::Int64ToString(node->id()),
+                                             remove_info));
 }
 
 void BookmarkEventRouter::BookmarkAllNodesRemoved(BookmarkModel* model) {
@@ -248,21 +241,18 @@ void BookmarkEventRouter::BookmarkAllNodesRemoved(BookmarkModel* model) {
 
 void BookmarkEventRouter::BookmarkNodeChanged(BookmarkModel* model,
                                               const BookmarkNode* node) {
-  scoped_ptr<base::ListValue> args(new base::ListValue());
-  args->Append(new base::StringValue(base::Int64ToString(node->id())));
-
   // TODO(erikkay) The only three things that BookmarkModel sends this
   // notification for are title, url and favicon.  Since we're currently
   // ignoring favicon and since the notification doesn't say which one anyway,
   // for now we only include title and url.  The ideal thing would be to change
   // BookmarkModel to indicate what changed.
-  base::DictionaryValue* object_args = new base::DictionaryValue();
-  object_args->SetString(keys::kTitleKey, node->GetTitle());
-  if (node->is_url())
-    object_args->SetString(keys::kUrlKey, node->url().spec());
-  args->Append(object_args);
+  bookmarks::OnChanged::ChangeInfo change_info;
+  change_info.title = base::UTF16ToUTF8(node->GetTitle());
+  change_info.url.reset(new std::string(node->url().spec()));
 
-  DispatchEvent(bookmarks::OnChanged::kEventName, args.Pass());
+  DispatchEvent(bookmarks::OnChanged::kEventName,
+                bookmarks::OnChanged::Create(base::Int64ToString(node->id()),
+                                             change_info));
 }
 
 void BookmarkEventRouter::BookmarkNodeFaviconChanged(BookmarkModel* model,
@@ -273,32 +263,27 @@ void BookmarkEventRouter::BookmarkNodeFaviconChanged(BookmarkModel* model,
 void BookmarkEventRouter::BookmarkNodeChildrenReordered(
     BookmarkModel* model,
     const BookmarkNode* node) {
-  scoped_ptr<base::ListValue> args(new base::ListValue());
-  args->Append(new base::StringValue(base::Int64ToString(node->id())));
+  bookmarks::OnChildrenReordered::ReorderInfo reorder_info;
   int childCount = node->child_count();
-  base::ListValue* children = new base::ListValue();
   for (int i = 0; i < childCount; ++i) {
     const BookmarkNode* child = node->GetChild(i);
-    base::Value* child_id =
-        new base::StringValue(base::Int64ToString(child->id()));
-    children->Append(child_id);
+    reorder_info.child_ids.push_back(base::Int64ToString(child->id()));
   }
-  base::DictionaryValue* reorder_info = new base::DictionaryValue();
-  reorder_info->Set(keys::kChildIdsKey, children);
-  args->Append(reorder_info);
 
-  DispatchEvent(bookmarks::OnChildrenReordered::kEventName, args.Pass());
+  DispatchEvent(bookmarks::OnChildrenReordered::kEventName,
+                bookmarks::OnChildrenReordered::Create(
+                    base::Int64ToString(node->id()), reorder_info));
 }
 
 void BookmarkEventRouter::ExtensiveBookmarkChangesBeginning(
     BookmarkModel* model) {
-  scoped_ptr<base::ListValue> args(new base::ListValue());
-  DispatchEvent(bookmarks::OnImportBegan::kEventName, args.Pass());
+  DispatchEvent(bookmarks::OnImportBegan::kEventName,
+                bookmarks::OnImportBegan::Create());
 }
 
 void BookmarkEventRouter::ExtensiveBookmarkChangesEnded(BookmarkModel* model) {
-  scoped_ptr<base::ListValue> args(new base::ListValue());
-  DispatchEvent(bookmarks::OnImportEnded::kEventName, args.Pass());
+  DispatchEvent(bookmarks::OnImportEnded::kEventName,
+                bookmarks::OnImportEnded::Create());
 }
 
 BookmarksAPI::BookmarksAPI(BrowserContext* context)

chrome/chrome_browser_extensions.gypi

@@ -142,8 +142,6 @@
         'browser/extensions/api/bluetooth/bluetooth_extension_function.h',
         'browser/extensions/api/bookmark_manager_private/bookmark_manager_private_api.cc',
         'browser/extensions/api/bookmark_manager_private/bookmark_manager_private_api.h',
-        'browser/extensions/api/bookmark_manager_private/bookmark_manager_private_api_constants.cc',
-        'browser/extensions/api/bookmark_manager_private/bookmark_manager_private_api_constants.h',
         'browser/extensions/api/bookmarks/bookmark_api_constants.cc',
         'browser/extensions/api/bookmarks/bookmark_api_constants.h',
         'browser/extensions/api/bookmarks/bookmark_api_helpers.cc',