more extensions bookmarks changes:...

chrome/browser/extensions/extension_bookmarks_module.cc

 // Copyright (c) 2009 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/extension_bookmarks_module.h"
 
+#include "base/json_writer.h"
 #include "chrome/browser/bookmarks/bookmark_codec.h"
 #include "chrome/browser/bookmarks/bookmark_model.h"
 #include "chrome/browser/bookmarks/bookmark_utils.h"
+#include "chrome/browser/browser_list.h"
+#include "chrome/browser/extensions/extension_message_service.h"
 #include "chrome/browser/profile.h"
 
 namespace {
 // keys
 const wchar_t* kIdKey = L"id";
 const wchar_t* kIndexKey = L"index";
 const wchar_t* kParentIdKey = L"parentId";
+const wchar_t* kOldIndexKey = L"oldIndex";
+const wchar_t* kOldParentIdKey = L"oldParentId";
 const wchar_t* kUrlKey = L"url";
 const wchar_t* kTitleKey = L"title";
 const wchar_t* kChildrenIdsKey = L"childrenIds";
 const wchar_t* kChildrenKey = L"childrenIds";
 const wchar_t* kRecursiveKey = L"recursive";
 
 // errors
 const char* kNoNodeError = "Can't find bookmark for id.";
 const char* kNoParentError = "Can't find parent bookmark for id.";
 const char* kFolderNotEmptyError =
     "Can't remove non-empty folder (use recursive to force).";
 const char* kInvalidIndexError = "Index out of bounds.";
 const char* kInvalidUrlError = "Invalid URL.";
 const char* kModifySpecialError = "Can't modify the root bookmark folders.";
+
+// events
+const char* kOnBookmarkAdded = "bookmark-added";
+const char* kOnBookmarkRemoved = "bookmark-removed";
+const char* kOnBookmarkChanged = "bookmark-changed";
+const char* kOnBookmarkMoved = "bookmark-moved";
+const char* kOnBookmarkChildrenReordered = "bookmark-children-reordered";
 };
 
 // Helper functions.
 class ExtensionBookmarks {
  public:
   // Convert |node| into a JSON value
   static DictionaryValue* GetNodeDictionary(BookmarkNode* node, bool recurse) {
     DictionaryValue* dict = new DictionaryValue();
     dict->SetInteger(kIdKey, node->id());
 
@@ skipping 28 matching lines @@
   // Add a JSON representation of |node| to the JSON |list|.
   static void AddNode(BookmarkNode* node, ListValue* list, bool recurse) {
     DictionaryValue* dict = GetNodeDictionary(node, recurse);
     list->Append(dict);
   }
 
  private:
   ExtensionBookmarks();
 };
 
-// TODO(erikkay): add a recursive version
+void BookmarksFunction::Run() {
+  // TODO(erikkay) temporary hack until adding an event listener can notify the
+  // browser.
+  ExtensionBookmarkEventRouter* event_router =
+      ExtensionBookmarkEventRouter::GetSingleton();
+  BookmarkModel* model = profile()->GetBookmarkModel();
+  event_router->Observe(model);
+  SyncExtensionFunction::Run();
+}
+
+// static
+ExtensionBookmarkEventRouter* ExtensionBookmarkEventRouter::GetSingleton() {
+  return Singleton<ExtensionBookmarkEventRouter>::get();
+}
+
+ExtensionBookmarkEventRouter::ExtensionBookmarkEventRouter() {
+}
+
+ExtensionBookmarkEventRouter::~ExtensionBookmarkEventRouter() {
+}
+
+void ExtensionBookmarkEventRouter::Observe(BookmarkModel* model) {
+  if (models_.find(model) == models_.end()) {
+    model->AddObserver(this);
+    models_.insert(model);
+  }
+}
+
+void ExtensionBookmarkEventRouter::DispatchEvent(Profile *profile,
+                                                 const char* event_name,
+                                                 const std::string json_args) {
+  ExtensionMessageService::GetInstance(profile->GetRequestContext())->
+      DispatchEventToRenderers(event_name, json_args);
+}
+
+void ExtensionBookmarkEventRouter::Loaded(BookmarkModel* model) {
+  // TODO(erikkay): Do we need an event here?  It seems unlikely that
+  // an extension would load before bookmarks loaded.
+}
+
+void ExtensionBookmarkEventRouter::BookmarkNodeMoved(BookmarkModel* model,
+                                                     BookmarkNode* old_parent,
+                                                     int old_index,
+                                                     BookmarkNode* new_parent,
+                                                     int new_index) {
+  ListValue args;
+  DictionaryValue* object_args = new DictionaryValue();
+  BookmarkNode* node = new_parent->GetChild(new_index);
+  object_args->SetInteger(kIdKey, node->id());
+  object_args->SetInteger(kParentIdKey, new_parent->id());
+  object_args->SetInteger(kIndexKey, new_index);
+  object_args->SetInteger(kOldParentIdKey, old_parent->id());
+  object_args->SetInteger(kOldIndexKey, old_index);
+  args.Append(object_args);
+
+  std::string json_args;
+  JSONWriter::Write(&args, false, &json_args);
+  DispatchEvent(model->profile(), kOnBookmarkMoved, json_args);
+}
+
+void ExtensionBookmarkEventRouter::BookmarkNodeAdded(BookmarkModel* model,
+                                                     BookmarkNode* parent,
+                                                     int index) {
+  ListValue args;
+  DictionaryValue* object_args = new DictionaryValue();
+  BookmarkNode* node = parent->GetChild(index);
+  object_args->SetInteger(kIdKey, node->id());
+  object_args->SetString(kTitleKey, node->GetTitle());
+  object_args->SetString(kUrlKey, node->GetURL().spec());
+  object_args->SetInteger(kParentIdKey, parent->id());
+  object_args->SetInteger(kIndexKey, index);
+  args.Append(object_args);
+
+  std::string json_args;
+  JSONWriter::Write(&args, false, &json_args);
+  DispatchEvent(model->profile(), kOnBookmarkAdded, json_args);
+}
+
+void ExtensionBookmarkEventRouter::BookmarkNodeRemoved(BookmarkModel* model,
+                                                       BookmarkNode* parent,
+                                                       int index) {
+  ListValue args;
+  DictionaryValue* object_args = new DictionaryValue();
+  object_args->SetInteger(kParentIdKey, parent->id());
+  object_args->SetInteger(kIndexKey, index);
+  args.Append(object_args);
+
+  std::string json_args;
+  JSONWriter::Write(&args, false, &json_args);
+  DispatchEvent(model->profile(), kOnBookmarkRemoved, json_args);
+}
+
+void ExtensionBookmarkEventRouter::BookmarkNodeChanged(BookmarkModel* model,
+                                                       BookmarkNode* node) {
+  ListValue args;
+  args.Append(new FundamentalValue(node->id()));
+
+  // TODO(erikkay) The only two things that BookmarkModel sends this
+  // notification for are title and favicon.  Since we're currently ignoring
+  // favicon and since the notification doesn't say which one anyway, for now
+  // we only include title.  The ideal thing would be to change BookmarkModel
+  // to indicate what changed.
+  DictionaryValue* object_args = new DictionaryValue();
+  object_args->SetString(kTitleKey, node->GetTitle());
+  args.Append(object_args);
+
+  std::string json_args;
+  JSONWriter::Write(&args, false, &json_args);
+  DispatchEvent(model->profile(), kOnBookmarkChanged, json_args);
+}
+
+void ExtensionBookmarkEventRouter::BookmarkNodeFavIconLoaded(
+    BookmarkModel* model, BookmarkNode* node) {
+  // TODO(erikkay) anything we should do here?
+}
+
+void ExtensionBookmarkEventRouter::BookmarkNodeChildrenReordered(
+    BookmarkModel* model, BookmarkNode* node) {
+  ListValue args;
+  args.Append(new FundamentalValue(node->id()));
+  int childCount = node->GetChildCount();
+  ListValue* children = new ListValue();
+  for (int i = 0; i < childCount; ++i) {
+    BookmarkNode* child = node->GetChild(i);
+    Value* child_id = new FundamentalValue(child->id());
+    children->Append(child_id);
+  }
+  args.Append(children);
+
+  std::string json_args;
+  JSONWriter::Write(&args, false, &json_args);
+  DispatchEvent(model->profile(), kOnBookmarkChildrenReordered, json_args);
+}
+
 bool GetBookmarksFunction::RunImpl() {
   // TODO(erikkay): the JSON schema doesn't support the TYPE_INTEGER
   // variant yet.
   EXTENSION_FUNCTION_VALIDATE(args_->IsType(Value::TYPE_LIST) ||
                               args_->IsType(Value::TYPE_INTEGER) ||
                               args_->IsType(Value::TYPE_NULL));
   BookmarkModel* model = profile()->GetBookmarkModel();
   scoped_ptr<ListValue> json(new ListValue());
   if (args_->IsType(Value::TYPE_INTEGER)) {
     int id;
@@ skipping 30 matching lines @@
       if (error_.size() && json->GetSize() == 0) {
         return false;
       }
     }
   }
 
   result_.reset(json.release());
   return true;
 }
 
+bool GetBookmarkChildrenFunction::RunImpl() {
+  int id;
+  EXTENSION_FUNCTION_VALIDATE(args_->GetAsInteger(&id));
+  BookmarkModel* model = profile()->GetBookmarkModel();
+  scoped_ptr<ListValue> json(new ListValue());
+  BookmarkNode* node = model->GetNodeByID(id);
+  if (!node) {
+    error_ = kNoNodeError;
+    return false;
+  }
+  int child_count = node->GetChildCount();
+  for (int i = 0; i < child_count; ++i) {
+    BookmarkNode* child = node->GetChild(i);
+    ExtensionBookmarks::AddNode(child, json.get(), false);
+  }
+
+  result_.reset(json.release());
+  return true;
+}
+
+bool GetBookmarkTreeFunction::RunImpl() {
+  BookmarkModel* model = profile()->GetBookmarkModel();
+  scoped_ptr<ListValue> json(new ListValue());
+  BookmarkNode* node = model->root_node();
+  ExtensionBookmarks::AddNode(node, json.get(), true);
+  result_.reset(json.release());
+  return true;
+}
+
 bool SearchBookmarksFunction::RunImpl() {
   EXTENSION_FUNCTION_VALIDATE(args_->IsType(Value::TYPE_STRING));
 
   std::wstring query;
   EXTENSION_FUNCTION_VALIDATE(args_->GetAsString(&query));
 
   BookmarkModel* model = profile()->GetBookmarkModel();
   ListValue* json = new ListValue();
   std::vector<BookmarkNode*> nodes;
   bookmark_utils::GetBookmarksContainingText(model, query, 50, &nodes);
@@ skipping 175 matching lines @@
   }
   if (node == model->root_node() ||
       node == model->other_node() ||
       node == model->GetBookmarkBarNode()) {
     error_ = kModifySpecialError;
     return false;
   }
   model->SetTitle(node, title);
   return true;
 }
-