Make BookmarkAPI a PKS

Move BookmarksExtensionEventRouter and related to c/b/e/api/bookmark.
Create BookmarkAPI, a PKS for Bookmark.

This introduces a temporary new dependency for BookmarkManager API.  This is removed here: https://codereview.chromium.org/11516010/

BUG=159265, 101244
TBR=ben@chromium.org for gypi

Review URL: https://chromiumcodereview.appspot.com/11316223

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

19 files changed, 327 insertions, 178 deletions

diff --git a/chrome/browser/bookmarks/DEPS b/chrome/browser/bookmarks/DEPS
index d07579d..e0faf1c 100644
--- a/chrome/browser/bookmarks/DEPS
+++ b/chrome/browser/bookmarks/DEPS
@@ -10,12 +10,14 @@ include_rules = [
   # TODO(kaiwang): Bring this list to zero.
   # Do not add to the list of temporarily-allowed dependencies below,
   # and please do not introduce more #includes of these files.
+  "!chrome/browser/extensions/api/bookmarks/bookmark_api.h",
+  "!chrome/browser/extensions/api/bookmarks/bookmark_api_constants.h",
+  "!chrome/browser/extensions/api/bookmarks/bookmark_api_helpers.h",
   "!chrome/browser/extensions/event_router.h",
   "!chrome/browser/extensions/extension_function.h",
   "!chrome/browser/extensions/extension_function_dispatcher.h",
   "!chrome/browser/extensions/extension_system.h",
   "!chrome/browser/extensions/extension_web_ui.h",
-  "!chrome/browser/extensions/extensions_quota_service.h",
   "!chrome/browser/favicon/favicon_service.h",
   "!chrome/browser/favicon/favicon_service_factory.h",
   "!chrome/browser/history/history.h",
diff --git a/chrome/browser/bookmarks/bookmark_manager_extension_api.cc b/chrome/browser/bookmarks/bookmark_manager_extension_api.cc
index 0d3a218..385e909 100644
--- a/chrome/browser/bookmarks/bookmark_manager_extension_api.cc
+++ b/chrome/browser/bookmarks/bookmark_manager_extension_api.cc
@@ -10,12 +10,14 @@
 #include "base/prefs/public/pref_service_base.h"
 #include "base/string_number_conversions.h"
 #include "base/values.h"
-#include "chrome/browser/bookmarks/bookmark_extension_api_constants.h"
-#include "chrome/browser/bookmarks/bookmark_extension_helpers.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/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"
@@ -34,7 +36,7 @@
 #include "win8/util/win8_util.h"
 #endif  // OS_WIN
 
-namespace keys = bookmark_extension_api_constants;
+namespace keys = extensions::bookmark_api_constants;
 
 using content::WebContents;
 
@@ -490,11 +492,11 @@ bool GetSubtreeBookmarkManagerFunction::RunImpl() {
   }
   scoped_ptr<ListValue> json(new ListValue());
   if (folders_only) {
-    bookmark_extension_helpers::AddNodeFoldersOnly(node,
+    extensions::bookmark_api_helpers::AddNodeFoldersOnly(node,
                                                    json.get(),
                                                    true);
   } else {
-    bookmark_extension_helpers::AddNode(node, json.get(), true);
+    extensions::bookmark_api_helpers::AddNode(node, json.get(), true);
   }
   SetResult(json.release());
   return true;
diff --git a/chrome/browser/bookmarks/bookmark_manager_extension_api.h b/chrome/browser/bookmarks/bookmark_manager_extension_api.h
index 9e16f7c..dc24d13 100644
--- a/chrome/browser/bookmarks/bookmark_manager_extension_api.h
+++ b/chrome/browser/bookmarks/bookmark_manager_extension_api.h
@@ -6,8 +6,10 @@
 #define CHROME_BROWSER_BOOKMARKS_BOOKMARK_MANAGER_EXTENSION_API_H_
 
 #include "base/values.h"
-#include "chrome/browser/bookmarks/bookmark_extension_api.h"
 #include "chrome/browser/bookmarks/bookmark_node_data.h"
+// TODO (rdevlin.cronin): Move BookmarkManagerAPI to
+// chrome/browser/extensions/api/bookmark so these two aren't interdependent.
+#include "chrome/browser/extensions/api/bookmarks/bookmark_api.h"
 #include "chrome/browser/extensions/extension_function.h"
 #include "chrome/browser/ui/bookmarks/bookmark_tab_helper.h"
 
@@ -53,7 +55,7 @@ class BookmarkManagerExtensionEventRouter
   DISALLOW_COPY_AND_ASSIGN(BookmarkManagerExtensionEventRouter);
 };
 
-class ClipboardBookmarkManagerFunction : public BookmarksFunction {
+class ClipboardBookmarkManagerFunction : public extensions::BookmarksFunction {
  protected:
   virtual ~ClipboardBookmarkManagerFunction() {}
 
@@ -82,7 +84,7 @@ class CutBookmarkManagerFunction : public ClipboardBookmarkManagerFunction {
   virtual bool RunImpl() OVERRIDE;
 };
 
-class PasteBookmarkManagerFunction : public BookmarksFunction {
+class PasteBookmarkManagerFunction : public extensions::BookmarksFunction {
  public:
   DECLARE_EXTENSION_FUNCTION_NAME("bookmarkManagerPrivate.paste");
 
@@ -93,7 +95,7 @@ class PasteBookmarkManagerFunction : public BookmarksFunction {
   virtual bool RunImpl() OVERRIDE;
 };
 
-class CanPasteBookmarkManagerFunction : public BookmarksFunction {
+class CanPasteBookmarkManagerFunction : public extensions::BookmarksFunction {
  public:
   DECLARE_EXTENSION_FUNCTION_NAME("bookmarkManagerPrivate.canPaste");
 
@@ -104,7 +106,8 @@ class CanPasteBookmarkManagerFunction : public BookmarksFunction {
   virtual bool RunImpl() OVERRIDE;
 };
 
-class SortChildrenBookmarkManagerFunction : public BookmarksFunction {
+class SortChildrenBookmarkManagerFunction
+    : public extensions::BookmarksFunction {
  public:
   DECLARE_EXTENSION_FUNCTION_NAME("bookmarkManagerPrivate.sortChildren");
 
@@ -126,7 +129,7 @@ class BookmarkManagerGetStringsFunction : public AsyncExtensionFunction {
   virtual bool RunImpl() OVERRIDE;
 };
 
-class StartDragBookmarkManagerFunction : public BookmarksFunction {
+class StartDragBookmarkManagerFunction : public extensions::BookmarksFunction {
  public:
   DECLARE_EXTENSION_FUNCTION_NAME("bookmarkManagerPrivate.startDrag");
 
@@ -137,7 +140,7 @@ class StartDragBookmarkManagerFunction : public BookmarksFunction {
   virtual bool RunImpl() OVERRIDE;
 };
 
-class DropBookmarkManagerFunction : public BookmarksFunction {
+class DropBookmarkManagerFunction : public extensions::BookmarksFunction {
  public:
   DECLARE_EXTENSION_FUNCTION_NAME("bookmarkManagerPrivate.drop");
 
@@ -148,7 +151,7 @@ class DropBookmarkManagerFunction : public BookmarksFunction {
   virtual bool RunImpl() OVERRIDE;
 };
 
-class GetSubtreeBookmarkManagerFunction : public BookmarksFunction {
+class GetSubtreeBookmarkManagerFunction : public extensions::BookmarksFunction {
  public:
   DECLARE_EXTENSION_FUNCTION_NAME("bookmarkManagerPrivate.getSubtree");
 
@@ -159,7 +162,7 @@ class GetSubtreeBookmarkManagerFunction : public BookmarksFunction {
   virtual bool RunImpl() OVERRIDE;
 };
 
-class CanEditBookmarkManagerFunction : public BookmarksFunction {
+class CanEditBookmarkManagerFunction : public extensions::BookmarksFunction {
  public:
   DECLARE_EXTENSION_FUNCTION_NAME("bookmarkManagerPrivate.canEdit");
 
@@ -170,7 +173,7 @@ class CanEditBookmarkManagerFunction : public BookmarksFunction {
   virtual bool RunImpl() OVERRIDE;
 };
 
-class RecordLaunchBookmarkFunction : public BookmarksFunction {
+class RecordLaunchBookmarkFunction : public extensions::BookmarksFunction {
  public:
   DECLARE_EXTENSION_FUNCTION_NAME("bookmarkManagerPrivate.recordLaunch")
 
@@ -181,7 +184,7 @@ class RecordLaunchBookmarkFunction : public BookmarksFunction {
   virtual bool RunImpl() OVERRIDE;
 };
 
-class CanOpenNewWindowsBookmarkFunction : public BookmarksFunction {
+class CanOpenNewWindowsBookmarkFunction : public extensions::BookmarksFunction {
  public:
   DECLARE_EXTENSION_FUNCTION_NAME("bookmarkManagerPrivate.canOpenNewWindows");
 
diff --git a/chrome/browser/bookmarks/bookmark_extension_api.cc b/chrome/browser/extensions/api/bookmarks/bookmark_api.cc
index f23d625..c076813 100644
--- a/chrome/browser/bookmarks/bookmark_extension_api.cc
+++ b/chrome/browser/extensions/api/bookmarks/bookmark_api.cc
@@ -2,7 +2,7 @@
 // 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_extension_api.h"
+#include "chrome/browser/extensions/api/bookmarks/bookmark_api.h"
 
 #include "base/bind.h"
 #include "base/file_path.h"
@@ -20,12 +20,12 @@
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/bookmarks/bookmark_codec.h"
-#include "chrome/browser/bookmarks/bookmark_extension_api_constants.h"
-#include "chrome/browser/bookmarks/bookmark_extension_helpers.h"
 #include "chrome/browser/bookmarks/bookmark_html_writer.h"
 #include "chrome/browser/bookmarks/bookmark_model.h"
 #include "chrome/browser/bookmarks/bookmark_model_factory.h"
 #include "chrome/browser/bookmarks/bookmark_utils.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"
@@ -42,8 +42,10 @@
 #include "grit/generated_resources.h"
 #include "ui/base/l10n/l10n_util.h"
 
-namespace keys = bookmark_extension_api_constants;
-namespace bookmarks = extensions::api::bookmarks;
+namespace extensions {
+
+namespace keys = bookmark_api_constants;
+namespace bookmarks = api::bookmarks;
 
 using base::TimeDelta;
 using bookmarks::BookmarkTreeNode;
@@ -99,7 +101,7 @@ void BookmarksFunction::Run() {
   if (success) {
     content::NotificationService::current()->Notify(
         chrome::NOTIFICATION_EXTENSION_BOOKMARKS_API_INVOKED,
-        content::Source<const extensions::Extension>(GetExtension()),
+        content::Source<const Extension>(GetExtension()),
         content::Details<const BookmarksFunction>(this));
   }
   SendResponse(success);
@@ -135,18 +137,17 @@ void BookmarksFunction::Observe(int type,
   Release();  // Balanced in Run().
 }
 
-BookmarkExtensionEventRouter::BookmarkExtensionEventRouter(
-    BookmarkModel* model) : model_(model) {
+BookmarkEventRouter::BookmarkEventRouter(BookmarkModel* model) : model_(model) {
   model_->AddObserver(this);
 }
 
-BookmarkExtensionEventRouter::~BookmarkExtensionEventRouter() {
+BookmarkEventRouter::~BookmarkEventRouter() {
   if (model_) {
     model_->RemoveObserver(this);
   }
 }
 
-void BookmarkExtensionEventRouter::DispatchEvent(
+void BookmarkEventRouter::DispatchEvent(
     Profile* profile,
     const char* event_name,
     scoped_ptr<ListValue> event_args) {
@@ -156,23 +157,20 @@ void BookmarkExtensionEventRouter::DispatchEvent(
   }
 }
 
-void BookmarkExtensionEventRouter::Loaded(BookmarkModel* model,
-                                          bool ids_reassigned) {
+void BookmarkEventRouter::Loaded(BookmarkModel* model, bool ids_reassigned) {
   // TODO(erikkay): Perhaps we should send this event down to the extension
   // so they know when it's safe to use the API?
 }
 
-void BookmarkExtensionEventRouter::BookmarkModelBeingDeleted(
-    BookmarkModel* model) {
+void BookmarkEventRouter::BookmarkModelBeingDeleted(BookmarkModel* model) {
   model_ = NULL;
 }
 
-void BookmarkExtensionEventRouter::BookmarkNodeMoved(
-    BookmarkModel* model,
-    const BookmarkNode* old_parent,
-    int old_index,
-    const BookmarkNode* new_parent,
-    int new_index) {
+void BookmarkEventRouter::BookmarkNodeMoved(BookmarkModel* model,
+                                            const BookmarkNode* old_parent,
+                                            int old_index,
+                                            const BookmarkNode* new_parent,
+                                            int new_index) {
   scoped_ptr<ListValue> args(new ListValue());
   const BookmarkNode* node = new_parent->GetChild(new_index);
   args->Append(new StringValue(base::Int64ToString(node->id())));
@@ -188,24 +186,23 @@ void BookmarkExtensionEventRouter::BookmarkNodeMoved(
   DispatchEvent(model->profile(), keys::kOnBookmarkMoved, args.Pass());
 }
 
-void BookmarkExtensionEventRouter::BookmarkNodeAdded(BookmarkModel* model,
-                                                     const BookmarkNode* parent,
-                                                     int index) {
+void BookmarkEventRouter::BookmarkNodeAdded(BookmarkModel* model,
+                                            const BookmarkNode* parent,
+                                            int index) {
   scoped_ptr<ListValue> args(new ListValue());
   const BookmarkNode* node = parent->GetChild(index);
   args->Append(new StringValue(base::Int64ToString(node->id())));
   scoped_ptr<BookmarkTreeNode> tree_node(
-      bookmark_extension_helpers::GetBookmarkTreeNode(node, false, false));
+      bookmark_api_helpers::GetBookmarkTreeNode(node, false, false));
   args->Append(tree_node->ToValue().release());
 
   DispatchEvent(model->profile(), keys::kOnBookmarkCreated, args.Pass());
 }
 
-void BookmarkExtensionEventRouter::BookmarkNodeRemoved(
-    BookmarkModel* model,
-    const BookmarkNode* parent,
-    int index,
-    const BookmarkNode* node) {
+void BookmarkEventRouter::BookmarkNodeRemoved(BookmarkModel* model,
+                                              const BookmarkNode* parent,
+                                              int index,
+                                              const BookmarkNode* node) {
   scoped_ptr<ListValue> args(new ListValue());
   args->Append(new StringValue(base::Int64ToString(node->id())));
   DictionaryValue* object_args = new DictionaryValue();
@@ -217,8 +214,8 @@ void BookmarkExtensionEventRouter::BookmarkNodeRemoved(
   DispatchEvent(model->profile(), keys::kOnBookmarkRemoved, args.Pass());
 }
 
-void BookmarkExtensionEventRouter::BookmarkNodeChanged(
-    BookmarkModel* model, const BookmarkNode* node) {
+void BookmarkEventRouter::BookmarkNodeChanged(BookmarkModel* model,
+                                              const BookmarkNode* node) {
   scoped_ptr<ListValue> args(new ListValue());
   args->Append(new StringValue(base::Int64ToString(node->id())));
 
@@ -236,13 +233,14 @@ void BookmarkExtensionEventRouter::BookmarkNodeChanged(
   DispatchEvent(model->profile(), keys::kOnBookmarkChanged, args.Pass());
 }
 
-void BookmarkExtensionEventRouter::BookmarkNodeFaviconChanged(
-    BookmarkModel* model, const BookmarkNode* node) {
+void BookmarkEventRouter::BookmarkNodeFaviconChanged(BookmarkModel* model,
+                                                     const BookmarkNode* node) {
   // TODO(erikkay) anything we should do here?
 }
 
-void BookmarkExtensionEventRouter::BookmarkNodeChildrenReordered(
-    BookmarkModel* model, const BookmarkNode* node) {
+void BookmarkEventRouter::BookmarkNodeChildrenReordered(
+    BookmarkModel* model,
+    const BookmarkNode* node) {
   scoped_ptr<ListValue> args(new ListValue());
   args->Append(new StringValue(base::Int64ToString(node->id())));
   int childCount = node->child_count();
@@ -260,22 +258,51 @@ void BookmarkExtensionEventRouter::BookmarkNodeChildrenReordered(
                 args.Pass());
 }
 
-void BookmarkExtensionEventRouter::
-    ExtensiveBookmarkChangesBeginning(BookmarkModel* model) {
+void BookmarkEventRouter::ExtensiveBookmarkChangesBeginning(
+    BookmarkModel* model) {
   scoped_ptr<ListValue> args(new ListValue());
   DispatchEvent(model->profile(),
                 keys::kOnBookmarkImportBegan,
                 args.Pass());
 }
 
-void BookmarkExtensionEventRouter::ExtensiveBookmarkChangesEnded(
-    BookmarkModel* model) {
+void BookmarkEventRouter::ExtensiveBookmarkChangesEnded(BookmarkModel* model) {
   scoped_ptr<ListValue> args(new ListValue());
   DispatchEvent(model->profile(),
                 keys::kOnBookmarkImportEnded,
                 args.Pass());
 }
 
+BookmarkAPI::BookmarkAPI(Profile* profile) : profile_(profile) {
+  ExtensionSystem::Get(profile_)->event_router()->RegisterObserver(
+      this, keys::kOnBookmarkCreated);
+  ExtensionSystem::Get(profile_)->event_router()->RegisterObserver(
+      this, keys::kOnBookmarkRemoved);
+  ExtensionSystem::Get(profile_)->event_router()->RegisterObserver(
+      this, keys::kOnBookmarkChanged);
+  ExtensionSystem::Get(profile_)->event_router()->RegisterObserver(
+      this, keys::kOnBookmarkMoved);
+  ExtensionSystem::Get(profile_)->event_router()->RegisterObserver(
+      this, keys::kOnBookmarkChildrenReordered);
+  ExtensionSystem::Get(profile_)->event_router()->RegisterObserver(
+      this, keys::kOnBookmarkImportBegan);
+  ExtensionSystem::Get(profile_)->event_router()->RegisterObserver(
+      this, keys::kOnBookmarkImportEnded);
+}
+
+BookmarkAPI::~BookmarkAPI() {
+}
+
+void BookmarkAPI::Shutdown() {
+  ExtensionSystem::Get(profile_)->event_router()->UnregisterObserver(this);
+}
+
+void BookmarkAPI::OnListenerAdded(const EventListenerInfo& details) {
+  bookmark_event_router_.reset(new BookmarkEventRouter(
+      BookmarkModelFactory::GetForProfile(profile_)));
+  ExtensionSystem::Get(profile_)->event_router()->UnregisterObserver(this);
+}
+
 bool GetBookmarksFunction::RunImpl() {
   scoped_ptr<bookmarks::Get::Params> params(
       bookmarks::Get::Params::Create(*args_));
@@ -297,7 +324,7 @@ bool GetBookmarksFunction::RunImpl() {
         error_ = keys::kNoNodeError;
         return false;
       } else {
-        bookmark_extension_helpers::AddNode(node, &nodes, false);
+        bookmark_api_helpers::AddNode(node, &nodes, false);
       }
     }
   } else {
@@ -309,7 +336,7 @@ bool GetBookmarksFunction::RunImpl() {
       error_ = keys::kNoNodeError;
       return false;
     }
-    bookmark_extension_helpers::AddNode(node, &nodes, false);
+    bookmark_api_helpers::AddNode(node, &nodes, false);
   }
 
   results_ = bookmarks::Get::Results::Create(nodes);
@@ -335,7 +362,7 @@ bool GetBookmarkChildrenFunction::RunImpl() {
   int child_count = node->child_count();
   for (int i = 0; i < child_count; ++i) {
     const BookmarkNode* child = node->GetChild(i);
-    bookmark_extension_helpers::AddNode(child, &nodes, false);
+    bookmark_api_helpers::AddNode(child, &nodes, false);
   }
 
   results_ = bookmarks::GetChildren::Results::Create(nodes);
@@ -359,7 +386,7 @@ bool GetBookmarkRecentFunction::RunImpl() {
   std::vector<const BookmarkNode*>::iterator i = nodes.begin();
   for (; i != nodes.end(); ++i) {
     const BookmarkNode* node = *i;
-    bookmark_extension_helpers::AddNode(node, &tree_nodes, false);
+    bookmark_api_helpers::AddNode(node, &tree_nodes, false);
   }
 
   results_ = bookmarks::GetRecent::Results::Create(tree_nodes);
@@ -370,7 +397,7 @@ bool GetBookmarkTreeFunction::RunImpl() {
   std::vector<linked_ptr<BookmarkTreeNode> > nodes;
   const BookmarkNode* node =
       BookmarkModelFactory::GetForProfile(profile())->root_node();
-  bookmark_extension_helpers::AddNode(node, &nodes, true);
+  bookmark_api_helpers::AddNode(node, &nodes, true);
   results_ = bookmarks::GetTree::Results::Create(nodes);
   return true;
 }
@@ -392,7 +419,7 @@ bool GetBookmarkSubTreeFunction::RunImpl() {
   }
 
   std::vector<linked_ptr<BookmarkTreeNode> > nodes;
-  bookmark_extension_helpers::AddNode(node, &nodes, true);
+  bookmark_api_helpers::AddNode(node, &nodes, true);
   results_ = bookmarks::GetSubTree::Results::Create(nodes);
   return true;
 }
@@ -415,7 +442,7 @@ bool SearchBookmarksFunction::RunImpl() {
   std::vector<linked_ptr<BookmarkTreeNode> > tree_nodes;
   for (std::vector<const BookmarkNode*>::iterator node_iter = nodes.begin();
        node_iter != nodes.end(); ++node_iter) {
-    bookmark_extension_helpers::AddNode(*node_iter, &tree_nodes, false);
+    bookmark_api_helpers::AddNode(*node_iter, &tree_nodes, false);
   }
 
   results_ = bookmarks::Search::Results::Create(tree_nodes);
@@ -456,7 +483,7 @@ bool RemoveBookmarkFunction::RunImpl() {
     recursive = true;
 
   BookmarkModel* model = BookmarkModelFactory::GetForProfile(profile());
-  if (!bookmark_extension_helpers::RemoveNode(model, id, recursive, &error_))
+  if (!bookmark_api_helpers::RemoveNode(model, id, recursive, &error_))
     return false;
 
   return true;
@@ -527,7 +554,7 @@ bool CreateBookmarkFunction::RunImpl() {
   }
 
   scoped_ptr<BookmarkTreeNode> ret(
-      bookmark_extension_helpers::GetBookmarkTreeNode(node, false, false));
+      bookmark_api_helpers::GetBookmarkTreeNode(node, false, false));
   results_ = bookmarks::Create::Results::Create(*ret);
 
   return true;
@@ -601,7 +628,7 @@ bool MoveBookmarkFunction::RunImpl() {
   model->Move(node, parent, index);
 
   scoped_ptr<BookmarkTreeNode> tree_node(
-      bookmark_extension_helpers::GetBookmarkTreeNode(node, false, false));
+      bookmark_api_helpers::GetBookmarkTreeNode(node, false, false));
   results_ = bookmarks::Move::Results::Create(*tree_node);
 
   return true;
@@ -664,7 +691,7 @@ bool UpdateBookmarkFunction::RunImpl() {
     model->SetURL(node, url);
 
   scoped_ptr<BookmarkTreeNode> tree_node(
-      bookmark_extension_helpers::GetBookmarkTreeNode(node, false, false));
+      bookmark_api_helpers::GetBookmarkTreeNode(node, false, false));
   results_ = bookmarks::Update::Results::Create(*tree_node);
   return true;
 }
@@ -965,3 +992,5 @@ void ExportBookmarksFunction::FileSelected(const FilePath& path,
 #endif
   Release();  // Balanced in BookmarksIOFunction::SelectFile()
 }
+
+}  // namespace extensions
diff --git a/chrome/browser/bookmarks/bookmark_extension_api.h b/chrome/browser/extensions/api/bookmarks/bookmark_api.h
index a953b5b..c3008246 100644
--- a/chrome/browser/bookmarks/bookmark_extension_api.h
+++ b/chrome/browser/extensions/api/bookmarks/bookmark_api.h
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef CHROME_BROWSER_BOOKMARKS_BOOKMARK_EXTENSION_API_H_
-#define CHROME_BROWSER_BOOKMARKS_BOOKMARK_EXTENSION_API_H_
+#ifndef CHROME_BROWSER_EXTENSIONS_API_BOOKMARKS_BOOKMARK_API_H_
+#define CHROME_BROWSER_EXTENSIONS_API_BOOKMARKS_BOOKMARK_API_H_
 
 #include <list>
 #include <string>
@@ -12,7 +12,9 @@
 #include "base/compiler_specific.h"
 #include "base/memory/ref_counted.h"
 #include "chrome/browser/bookmarks/bookmark_model_observer.h"
+#include "chrome/browser/extensions/event_router.h"
 #include "chrome/browser/extensions/extension_function.h"
+#include "chrome/browser/profiles/profile_keyed_service.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
 #include "ui/base/dialogs/select_file_dialog.h"
@@ -23,12 +25,14 @@ namespace base {
 class ListValue;
 }
 
+namespace extensions {
+
 // Observes BookmarkModel and then routes the notifications as events to
 // the extension system.
-class BookmarkExtensionEventRouter : public BookmarkModelObserver {
+class BookmarkEventRouter : public BookmarkModelObserver {
  public:
-  explicit BookmarkExtensionEventRouter(BookmarkModel* model);
-  virtual ~BookmarkExtensionEventRouter();
+  explicit BookmarkEventRouter(BookmarkModel* model);
+  virtual ~BookmarkEventRouter();
 
   // BookmarkModelObserver:
   virtual void Loaded(BookmarkModel* model, bool ids_reassigned) OVERRIDE;
@@ -62,7 +66,27 @@ class BookmarkExtensionEventRouter : public BookmarkModelObserver {
 
   BookmarkModel* model_;
 
-  DISALLOW_COPY_AND_ASSIGN(BookmarkExtensionEventRouter);
+  DISALLOW_COPY_AND_ASSIGN(BookmarkEventRouter);
+};
+
+class BookmarkAPI : public ProfileKeyedService,
+                    public EventRouter::Observer {
+ public:
+  explicit BookmarkAPI(Profile* profile);
+  virtual ~BookmarkAPI();
+
+  // ProfileKeyedService implementation.
+  virtual void Shutdown() OVERRIDE;
+
+  // EventRouter::Observer implementation.
+  virtual void OnListenerAdded(const EventListenerInfo& details)
+      OVERRIDE;
+
+ private:
+  Profile* profile_;
+
+  // Created lazily upon OnListenerAdded.
+  scoped_ptr<BookmarkEventRouter> bookmark_event_router_;
 };
 
 class BookmarksFunction : public AsyncExtensionFunction,
@@ -292,4 +316,6 @@ class ExportBookmarksFunction : public BookmarksIOFunction {
   virtual bool RunImpl() OVERRIDE;
 };
 
-#endif  // CHROME_BROWSER_BOOKMARKS_BOOKMARK_EXTENSION_API_H_
+}  // namespace extensions
+
+#endif  // CHROME_BROWSER_EXTENSIONS_API_BOOKMARKS_BOOKMARK_API_H_
diff --git a/chrome/browser/bookmarks/bookmark_extension_api_constants.cc b/chrome/browser/extensions/api/bookmarks/bookmark_api_constants.cc
index f2fa730..be68170 100644
--- a/chrome/browser/bookmarks/bookmark_extension_api_constants.cc
+++ b/chrome/browser/extensions/api/bookmarks/bookmark_api_constants.cc
@@ -2,9 +2,10 @@
 // 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_extension_api_constants.h"
+#include "chrome/browser/extensions/api/bookmarks/bookmark_api_constants.h"
 
-namespace bookmark_extension_api_constants {
+namespace extensions {
+namespace bookmark_api_constants {
 
 const char kIdKey[] = "id";
 const char kIndexKey[] = "index";
@@ -45,4 +46,5 @@ const char kOnBookmarkDragEnter[] = "bookmarkManagerPrivate.onDragEnter";
 const char kOnBookmarkDragLeave[] = "bookmarkManagerPrivate.onDragLeave";
 const char kOnBookmarkDrop[] = "bookmarkManagerPrivate.onDrop";
 
-}  // namespace bookmark_extension_api_constants
+}  // namespace bookmark_api_constants
+}  // namespace extensions
diff --git a/chrome/browser/bookmarks/bookmark_extension_api_constants.h b/chrome/browser/extensions/api/bookmarks/bookmark_api_constants.h
index 1eec5d9..9a9de23 100644
--- a/chrome/browser/bookmarks/bookmark_extension_api_constants.h
+++ b/chrome/browser/extensions/api/bookmarks/bookmark_api_constants.h
@@ -2,12 +2,13 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-// Constants used to for the Bookmarks API.
+#ifndef CHROME_BROWSER_EXTENSIONS_API_BOOKMARKS_BOOKMARK_API_CONSTANTS_H_
+#define CHROME_BROWSER_EXTENSIONS_API_BOOKMARKS_BOOKMARK_API_CONSTANTS_H_
 
-#ifndef CHROME_BROWSER_BOOKMARKS_BOOKMARK_EXTENSION_API_CONSTANTS_H_
-#define CHROME_BROWSER_BOOKMARKS_BOOKMARK_EXTENSION_API_CONSTANTS_H_
+// Constants used for the Bookmarks API.
 
-namespace bookmark_extension_api_constants {
+namespace extensions {
+namespace bookmark_api_constants {
 
 // Keys.
 extern const char kIdKey[];
@@ -49,6 +50,7 @@ extern const char kOnBookmarkDragEnter[];
 extern const char kOnBookmarkDragLeave[];
 extern const char kOnBookmarkDrop[];
 
-};  // namespace bookmark_extension_api_constants
+}  // namespace bookmark_api_constants
+}  // namespace extensions
 
-#endif  // CHROME_BROWSER_BOOKMARKS_BOOKMARK_EXTENSION_API_CONSTANTS_H_
+#endif  // CHROME_BROWSER_EXTENSIONS_API_BOOKMARKS_BOOKMARK_API_CONSTANTS_H_
diff --git a/chrome/browser/extensions/api/bookmarks/bookmark_api_factory.cc b/chrome/browser/extensions/api/bookmarks/bookmark_api_factory.cc
new file mode 100644
index 0000000..3f20629
--- /dev/null
+++ b/chrome/browser/extensions/api/bookmarks/bookmark_api_factory.cc
@@ -0,0 +1,47 @@
+// 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/bookmarks/bookmark_api_factory.h"
+
+#include "chrome/browser/extensions/api/bookmarks/bookmark_api.h"
+#include "chrome/browser/extensions/extension_system_factory.h"
+#include "chrome/browser/profiles/profile_dependency_manager.h"
+
+namespace extensions {
+
+// static
+BookmarkAPI* BookmarkAPIFactory::GetForProfile(
+    Profile* profile) {
+  return static_cast<BookmarkAPI*>(
+      GetInstance()->GetServiceForProfile(profile, true));
+}
+
+// static
+BookmarkAPIFactory* BookmarkAPIFactory::GetInstance() {
+  return Singleton<BookmarkAPIFactory>::get();
+}
+
+BookmarkAPIFactory::BookmarkAPIFactory()
+    : ProfileKeyedServiceFactory("BookmarkAPI",
+                                 ProfileDependencyManager::GetInstance()) {
+  DependsOn(ExtensionSystemFactory::GetInstance());
+}
+
+BookmarkAPIFactory::~BookmarkAPIFactory() {
+}
+
+ProfileKeyedService* BookmarkAPIFactory::BuildServiceInstanceFor(
+    Profile* profile) const {
+  return new BookmarkAPI(profile);
+}
+
+bool BookmarkAPIFactory::ServiceIsCreatedWithProfile() const {
+  return true;
+}
+
+bool BookmarkAPIFactory::ServiceIsNULLWhileTesting() const {
+  return true;
+}
+
+}  // namespace extensions
diff --git a/chrome/browser/extensions/api/bookmarks/bookmark_api_factory.h b/chrome/browser/extensions/api/bookmarks/bookmark_api_factory.h
new file mode 100644
index 0000000..19f8537
--- /dev/null
+++ b/chrome/browser/extensions/api/bookmarks/bookmark_api_factory.h
@@ -0,0 +1,35 @@
+// 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_BOOKMARKS_BOOKMARK_API_FACTORY_H_
+#define CHROME_BROWSER_EXTENSIONS_API_BOOKMARKS_BOOKMARK_API_FACTORY_H_
+
+#include "base/memory/singleton.h"
+#include "chrome/browser/profiles/profile_keyed_service_factory.h"
+
+namespace extensions {
+class BookmarkAPI;
+
+class BookmarkAPIFactory : public ProfileKeyedServiceFactory {
+ public:
+  static BookmarkAPI* GetForProfile(Profile* profile);
+
+  static BookmarkAPIFactory* GetInstance();
+
+ private:
+  friend struct DefaultSingletonTraits<BookmarkAPIFactory>;
+
+  BookmarkAPIFactory();
+  virtual ~BookmarkAPIFactory();
+
+  // ProfileKeyedBaseFactory implementation.
+  virtual ProfileKeyedService* BuildServiceInstanceFor(
+      Profile* profile) const OVERRIDE;
+  virtual bool ServiceIsCreatedWithProfile() const OVERRIDE;
+  virtual bool ServiceIsNULLWhileTesting() const OVERRIDE;
+};
+
+}  // namespace extensions
+
+#endif  // CHROME_BROWSER_EXTENSIONS_API_BOOKMARKS_BOOKMARK_API_FACTORY_H_
diff --git a/chrome/browser/bookmarks/bookmark_extension_helpers.cc b/chrome/browser/extensions/api/bookmarks/bookmark_api_helpers.cc
index 6b35cbc..fcf258e 100644
--- a/chrome/browser/bookmarks/bookmark_extension_helpers.cc
+++ b/chrome/browser/extensions/api/bookmarks/bookmark_api_helpers.cc
@@ -2,7 +2,7 @@
 // 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_extension_helpers.h"
+#include "chrome/browser/extensions/api/bookmarks/bookmark_api_helpers.h"
 
 #include <math.h>  // For floor()
 #include <vector>
@@ -10,46 +10,46 @@
 #include "base/string_number_conversions.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
-#include "chrome/browser/bookmarks/bookmark_extension_api_constants.h"
 #include "chrome/browser/bookmarks/bookmark_model.h"
+#include "chrome/browser/extensions/api/bookmarks/bookmark_api_constants.h"
 #include "chrome/common/extensions/api/bookmarks.h"
 
-using extensions::api::bookmarks::BookmarkTreeNode;
+namespace extensions {
 
-namespace keys = bookmark_extension_api_constants;
+namespace keys = bookmark_api_constants;
+using api::bookmarks::BookmarkTreeNode;
+
+namespace bookmark_api_helpers {
 
 namespace {
 
-void AddNode(const BookmarkNode* node,
-             std::vector<linked_ptr<BookmarkTreeNode> >* nodes,
-             bool recurse,
-             bool only_folders) {
+void AddNodeHelper(const BookmarkNode* node,
+                   std::vector<linked_ptr<BookmarkTreeNode> >* nodes,
+                   bool recurse,
+                   bool only_folders) {
   if (node->IsVisible()) {
-    linked_ptr<BookmarkTreeNode> new_node(
-        bookmark_extension_helpers::GetBookmarkTreeNode(node,
-                                                        recurse,
-                                                        only_folders));
+    linked_ptr<BookmarkTreeNode> new_node(GetBookmarkTreeNode(node,
+                                                              recurse,
+                                                              only_folders));
     nodes->push_back(new_node);
   }
 }
 
 // TODO(mwrosen): Remove this function once chrome.bookmarkManagerPrivate is
 // refactored to use the JSON schema compiler.
-void AddNode(const BookmarkNode* node,
-             base::ListValue* list,
-             bool recurse,
-             bool only_folders) {
+void AddNodeHelper(const BookmarkNode* node,
+                   base::ListValue* list,
+                   bool recurse,
+                   bool only_folders) {
   if (node->IsVisible()) {
-    base::DictionaryValue* dict = bookmark_extension_helpers::GetNodeDictionary(
-        node, recurse, only_folders);
+    base::DictionaryValue* dict =
+        GetNodeDictionary(node, recurse, only_folders);
     list->Append(dict);
   }
 }
 
 }  // namespace
 
-namespace bookmark_extension_helpers {
-
 BookmarkTreeNode* GetBookmarkTreeNode(const BookmarkNode* node,
                                       bool recurse,
                                       bool only_folders) {
@@ -144,23 +144,23 @@ base::DictionaryValue* GetNodeDictionary(const BookmarkNode* node,
 void AddNode(const BookmarkNode* node,
              std::vector<linked_ptr<BookmarkTreeNode> >* nodes,
              bool recurse) {
-  return ::AddNode(node, nodes, recurse, false);
+  return AddNodeHelper(node, nodes, recurse, false);
 }
 
 void AddNodeFoldersOnly(const BookmarkNode* node,
                         std::vector<linked_ptr<BookmarkTreeNode> >* nodes,
                         bool recurse) {
-  return ::AddNode(node, nodes, recurse, true);
+  return AddNodeHelper(node, nodes, recurse, true);
 }
 
 void AddNode(const BookmarkNode* node, base::ListValue* list, bool recurse) {
-  return ::AddNode(node, list, recurse, false);
+  return AddNodeHelper(node, list, recurse, false);
 }
 
 void AddNodeFoldersOnly(const BookmarkNode* node,
                         base::ListValue* list,
                         bool recurse) {
-  return ::AddNode(node, list, recurse, true);
+  return AddNodeHelper(node, list, recurse, true);
 }
 
 bool RemoveNode(BookmarkModel* model,
@@ -186,4 +186,5 @@ bool RemoveNode(BookmarkModel* model,
   return true;
 }
 
-}  // namespace bookmark_extension_helpers
+}  // namespace bookmark_api_helpers
+}  // namespace extensions
diff --git a/chrome/browser/bookmarks/bookmark_extension_helpers.h b/chrome/browser/extensions/api/bookmarks/bookmark_api_helpers.h
index b5fb4ec..8e89ea8 100644
--- a/chrome/browser/bookmarks/bookmark_extension_helpers.h
+++ b/chrome/browser/extensions/api/bookmarks/bookmark_api_helpers.h
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef CHROME_BROWSER_BOOKMARKS_BOOKMARK_EXTENSION_HELPERS_H_
-#define CHROME_BROWSER_BOOKMARKS_BOOKMARK_EXTENSION_HELPERS_H_
+#ifndef CHROME_BROWSER_EXTENSIONS_API_BOOKMARKS_BOOKMARK_API_HELPERS_H_
+#define CHROME_BROWSER_EXTENSIONS_API_BOOKMARKS_BOOKMARK_API_HELPERS_H_
 
 #include <string>
 #include <vector>
@@ -15,10 +15,11 @@ class BookmarkModel;
 class BookmarkNode;
 
 // Helper functions.
-namespace bookmark_extension_helpers {
+namespace extensions {
+namespace bookmark_api_helpers {
 
 // The returned value is owned by the caller.
-extensions::api::bookmarks::BookmarkTreeNode* GetBookmarkTreeNode(
+api::bookmarks::BookmarkTreeNode* GetBookmarkTreeNode(
     const BookmarkNode* node,
     bool recurse,
     bool only_folders);
@@ -31,14 +32,12 @@ base::DictionaryValue* GetNodeDictionary(const BookmarkNode* node,
 
 // Add a JSON representation of |node| to the JSON |nodes|.
 void AddNode(const BookmarkNode* node,
-             std::vector<linked_ptr<
-                 extensions::api::bookmarks::BookmarkTreeNode> >* nodes,
+             std::vector<linked_ptr<api::bookmarks::BookmarkTreeNode> >* nodes,
              bool recurse);
 
 void AddNodeFoldersOnly(const BookmarkNode* node,
                         std::vector<linked_ptr<
-                            extensions::api::bookmarks::BookmarkTreeNode> >*
-                                nodes,
+                            api::bookmarks::BookmarkTreeNode> >* nodes,
                         bool recurse);
 
 // TODO(mwrosen): Remove this function once chrome.bookmarkManagerPrivate is
@@ -58,6 +57,7 @@ bool RemoveNode(BookmarkModel* model,
                 bool recursive,
                 std::string* error);
 
-}  // namespace bookmark_extension_helpers
+}  // namespace bookmark_api_helpers
+}  // namespace extensions
 
-#endif  // CHROME_BROWSER_BOOKMARKS_BOOKMARK_EXTENSION_HELPERS_H_
+#endif  // CHROME_BROWSER_EXTENSIONS_API_BOOKMARKS_BOOKMARK_API_HELPERS_H_
diff --git a/chrome/browser/bookmarks/bookmark_extension_helpers_unittest.cc b/chrome/browser/extensions/api/bookmarks/bookmark_api_helpers_unittest.cc
index a2d54d3..19a6c70 100644
--- a/chrome/browser/bookmarks/bookmark_extension_helpers_unittest.cc
+++ b/chrome/browser/extensions/api/bookmarks/bookmark_api_helpers_unittest.cc
@@ -2,19 +2,22 @@
 // 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_extension_helpers.h"
+#include "chrome/browser/extensions/api/bookmarks/bookmark_api_helpers.h"
 
 #include "base/memory/scoped_ptr.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
-#include "chrome/browser/bookmarks/bookmark_extension_api_constants.h"
 #include "chrome/browser/bookmarks/bookmark_model.h"
+#include "chrome/browser/extensions/api/bookmarks/bookmark_api_constants.h"
 #include "chrome/common/extensions/api/bookmarks.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
-namespace keys = bookmark_extension_api_constants;
+namespace extensions {
 
-using extensions::api::bookmarks::BookmarkTreeNode;
+namespace keys = bookmark_api_constants;
+using api::bookmarks::BookmarkTreeNode;
+
+namespace bookmark_api_helpers {
 
 class ExtensionBookmarksTest : public testing::Test {
  public:
@@ -37,28 +40,25 @@ class ExtensionBookmarksTest : public testing::Test {
 };
 TEST_F(ExtensionBookmarksTest, GetFullTreeFromRoot) {
   scoped_ptr<BookmarkTreeNode> tree(
-      bookmark_extension_helpers::GetBookmarkTreeNode(
-          model_->other_node(),
-          true,    // Recurse.
-          false));  // Not only folders.
+      GetBookmarkTreeNode(model_->other_node(),
+                          true,    // Recurse.
+                          false));  // Not only folders.
   ASSERT_EQ(3U, tree->children->size());
 }
 
 TEST_F(ExtensionBookmarksTest, GetFoldersOnlyFromRoot) {
   scoped_ptr<BookmarkTreeNode> tree(
-      bookmark_extension_helpers::GetBookmarkTreeNode(
-          model_->other_node(),
-          true,   // Recurse.
-          true));  // Only folders.
+      GetBookmarkTreeNode(model_->other_node(),
+                          true,   // Recurse.
+                          true));  // Only folders.
   ASSERT_EQ(1U, tree->children->size());
 }
 
 TEST_F(ExtensionBookmarksTest, GetSubtree) {
   scoped_ptr<BookmarkTreeNode> tree(
-      bookmark_extension_helpers::GetBookmarkTreeNode(
-          folder_,
-          true,    // Recurse.
-          false));  // Not only folders.
+      GetBookmarkTreeNode(folder_,
+                          true,    // Recurse.
+                          false));  // Not only folders.
   ASSERT_EQ(4U, tree->children->size());
   linked_ptr<BookmarkTreeNode> digg = tree->children->at(1);
   ASSERT_TRUE(digg.get());
@@ -67,12 +67,14 @@ TEST_F(ExtensionBookmarksTest, GetSubtree) {
 
 TEST_F(ExtensionBookmarksTest, GetSubtreeFoldersOnly) {
   scoped_ptr<BookmarkTreeNode> tree(
-      bookmark_extension_helpers::GetBookmarkTreeNode(
-          folder_,
-          true,   // Recurse.
-          true));  // Only folders.
+      GetBookmarkTreeNode(folder_,
+                          true,   // Recurse.
+                          true));  // Only folders.
   ASSERT_EQ(2U, tree->children->size());
   linked_ptr<BookmarkTreeNode> inner_folder = tree->children->at(1);
   ASSERT_TRUE(inner_folder.get());
   ASSERT_EQ("inner folder 1", inner_folder->title);
 }
+
+}  // namespace bookmark_api_helpers
+}  // namespace extensions
diff --git a/chrome/browser/bookmarks/bookmark_extension_apitest.cc b/chrome/browser/extensions/api/bookmarks/bookmark_apitest.cc
index ebd6828..ebd6828 100644
--- a/chrome/browser/bookmarks/bookmark_extension_apitest.cc
+++ b/chrome/browser/extensions/api/bookmarks/bookmark_apitest.cc
diff --git a/chrome/browser/extensions/extension_function_registry.cc b/chrome/browser/extensions/extension_function_registry.cc
index ca1916d..197df79 100644
--- a/chrome/browser/extensions/extension_function_registry.cc
+++ b/chrome/browser/extensions/extension_function_registry.cc
@@ -5,9 +5,9 @@
 #include "chrome/browser/extensions/extension_function_registry.h"
 
 #include "chrome/browser/accessibility/accessibility_extension_api.h"
-#include "chrome/browser/bookmarks/bookmark_extension_api.h"
 #include "chrome/browser/bookmarks/bookmark_manager_extension_api.h"
 #include "chrome/browser/extensions/api/app/app_api.h"
+#include "chrome/browser/extensions/api/bookmarks/bookmark_api.h"
 #include "chrome/browser/extensions/api/browsing_data/browsing_data_api.h"
 #include "chrome/browser/extensions/api/cloud_print_private/cloud_print_private_api.h"
 #include "chrome/browser/extensions/api/commands/commands.h"
@@ -159,17 +159,19 @@ void ExtensionFunctionRegistry::ResetFunctions() {
   RegisterFunction<RemoveWebSQLFunction>();
 
   // Bookmarks.
-  RegisterFunction<GetBookmarksFunction>();
-  RegisterFunction<GetBookmarkChildrenFunction>();
-  RegisterFunction<GetBookmarkRecentFunction>();
-  RegisterFunction<GetBookmarkTreeFunction>();
-  RegisterFunction<GetBookmarkSubTreeFunction>();
-  RegisterFunction<SearchBookmarksFunction>();
-  RegisterFunction<RemoveBookmarkFunction>();
-  RegisterFunction<RemoveTreeBookmarkFunction>();
-  RegisterFunction<CreateBookmarkFunction>();
-  RegisterFunction<MoveBookmarkFunction>();
-  RegisterFunction<UpdateBookmarkFunction>();
+  RegisterFunction<extensions::GetBookmarksFunction>();
+  RegisterFunction<extensions::GetBookmarkChildrenFunction>();
+  RegisterFunction<extensions::GetBookmarkRecentFunction>();
+  RegisterFunction<extensions::GetBookmarkTreeFunction>();
+  RegisterFunction<extensions::GetBookmarkSubTreeFunction>();
+  RegisterFunction<extensions::ImportBookmarksFunction>();
+  RegisterFunction<extensions::ExportBookmarksFunction>();
+  RegisterFunction<extensions::SearchBookmarksFunction>();
+  RegisterFunction<extensions::RemoveBookmarkFunction>();
+  RegisterFunction<extensions::RemoveTreeBookmarkFunction>();
+  RegisterFunction<extensions::CreateBookmarkFunction>();
+  RegisterFunction<extensions::MoveBookmarkFunction>();
+  RegisterFunction<extensions::UpdateBookmarkFunction>();
 
   // Infobars.
   RegisterFunction<ShowInfoBarFunction>();
@@ -179,8 +181,6 @@ void ExtensionFunctionRegistry::ResetFunctions() {
   RegisterFunction<CutBookmarkManagerFunction>();
   RegisterFunction<PasteBookmarkManagerFunction>();
   RegisterFunction<CanPasteBookmarkManagerFunction>();
-  RegisterFunction<ImportBookmarksFunction>();
-  RegisterFunction<ExportBookmarksFunction>();
   RegisterFunction<SortChildrenBookmarkManagerFunction>();
   RegisterFunction<BookmarkManagerGetStringsFunction>();
   RegisterFunction<StartDragBookmarkManagerFunction>();
diff --git a/chrome/browser/extensions/extension_service.cc b/chrome/browser/extensions/extension_service.cc
index 7ea8eca..6645b89 100644
--- a/chrome/browser/extensions/extension_service.cc
+++ b/chrome/browser/extensions/extension_service.cc
@@ -27,7 +27,6 @@
 #include "base/values.h"
 #include "base/version.h"
 #include "chrome/browser/accessibility/accessibility_extension_api.h"
-#include "chrome/browser/bookmarks/bookmark_extension_api.h"
 #include "chrome/browser/bookmarks/bookmark_model_factory.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_plugin_service_filter.h"
@@ -523,8 +522,6 @@ void ExtensionService::InitEventRouters() {
 
 #if defined(ENABLE_EXTENSIONS)
   browser_event_router_.reset(new extensions::BrowserEventRouter(profile_));
-  bookmark_event_router_.reset(new BookmarkExtensionEventRouter(
-      BookmarkModelFactory::GetForProfile(profile_)));
 
 #if defined(OS_CHROMEOS)
   FileBrowserEventRouterFactory::GetForProfile(
diff --git a/chrome/browser/extensions/extension_service.h b/chrome/browser/extensions/extension_service.h
index 5d90af9..62154a0 100644
--- a/chrome/browser/extensions/extension_service.h
+++ b/chrome/browser/extensions/extension_service.h
@@ -40,7 +40,6 @@
 #include "sync/api/sync_change.h"
 #include "sync/api/syncable_service.h"
 
-class BookmarkExtensionEventRouter;
 class CommandLine;
 class ExtensionErrorUI;
 class ExtensionSyncData;
@@ -956,8 +955,6 @@ class ExtensionService
   // crbug.com/159265
   scoped_ptr<extensions::BrowserEventRouter> browser_event_router_;
 
-  scoped_ptr<BookmarkExtensionEventRouter> bookmark_event_router_;
-
 #if defined(OS_CHROMEOS)
   scoped_ptr<chromeos::ExtensionInputMethodEventRouter>
       input_method_event_router_;
diff --git a/chrome/browser/profiles/profile_dependency_manager.cc b/chrome/browser/profiles/profile_dependency_manager.cc
index fb357f2..9546550d 100644
--- a/chrome/browser/profiles/profile_dependency_manager.cc
+++ b/chrome/browser/profiles/profile_dependency_manager.cc
@@ -15,6 +15,7 @@
 #include "chrome/browser/custom_handlers/protocol_handler_registry_factory.h"
 #include "chrome/browser/download/download_service_factory.h"
 #include "chrome/browser/extensions/api/bluetooth/bluetooth_api_factory.h"
+#include "chrome/browser/extensions/api/bookmarks/bookmark_api_factory.h"
 #include "chrome/browser/extensions/api/commands/command_service_factory.h"
 #include "chrome/browser/extensions/api/cookies/cookies_api_factory.h"
 #include "chrome/browser/extensions/api/dial/dial_api_factory.h"
@@ -231,6 +232,7 @@ void ProfileDependencyManager::AssertFactoriesBuilt() {
   DownloadServiceFactory::GetInstance();
 #if defined(ENABLE_EXTENSIONS)
   extensions::AppRestoreServiceFactory::GetInstance();
+  extensions::BookmarkAPIFactory::GetInstance();
   extensions::BluetoothAPIFactory::GetInstance();
   extensions::CommandServiceFactory::GetInstance();
   extensions::CookiesAPIFactory::GetInstance();
diff --git a/chrome/browser/sync/glue/chrome_extensions_activity_monitor.cc b/chrome/browser/sync/glue/chrome_extensions_activity_monitor.cc
index 17ec604..1c6d472 100644
--- a/chrome/browser/sync/glue/chrome_extensions_activity_monitor.cc
+++ b/chrome/browser/sync/glue/chrome_extensions_activity_monitor.cc
@@ -5,7 +5,7 @@
 #include "chrome/browser/sync/glue/chrome_extensions_activity_monitor.h"
 
 #include "base/bind.h"
-#include "chrome/browser/bookmarks/bookmark_extension_api.h"
+#include "chrome/browser/extensions/api/bookmarks/bookmark_api.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/extensions/extension.h"
 #include "content/public/browser/browser_thread.h"
@@ -53,8 +53,8 @@ void ChromeExtensionsActivityMonitor::Observe(
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   const extensions::Extension* extension =
       content::Source<const extensions::Extension>(source).ptr();
-  const BookmarksFunction* f =
-      content::Details<const BookmarksFunction>(details).ptr();
+  const extensions::BookmarksFunction* f =
+      content::Details<const extensions::BookmarksFunction>(details).ptr();
   if (f->name() == "bookmarks.update" ||
       f->name() == "bookmarks.move" ||
       f->name() == "bookmarks.create" ||
diff --git a/chrome/browser/sync/glue/chrome_extensions_activity_monitor_unittest.cc b/chrome/browser/sync/glue/chrome_extensions_activity_monitor_unittest.cc
index 08d693d..f03e231 100644
--- a/chrome/browser/sync/glue/chrome_extensions_activity_monitor_unittest.cc
+++ b/chrome/browser/sync/glue/chrome_extensions_activity_monitor_unittest.cc
@@ -8,7 +8,7 @@
 #include "base/message_loop.h"
 #include "base/path_service.h"
 #include "base/values.h"
-#include "chrome/browser/bookmarks/bookmark_extension_api.h"
+#include "chrome/browser/extensions/api/bookmarks/bookmark_api.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/extensions/extension.h"
@@ -53,7 +53,8 @@ void FireBookmarksApiEvent(
     content::NotificationService::current()->Notify(
         chrome::NOTIFICATION_EXTENSION_BOOKMARKS_API_INVOKED,
         content::Source<Extension>(extension.get()),
-        content::Details<const BookmarksFunction>(bookmarks_function.get()));
+        content::Details<const extensions::BookmarksFunction>(
+            bookmarks_function.get()));
   }
 }
 
@@ -85,17 +86,18 @@ class SyncChromeExtensionsActivityMonitorTest : public testing::Test {
 // 2.  Only the mutating events should be recorded by the
 // syncer::ExtensionsActivityMonitor.
 TEST_F(SyncChromeExtensionsActivityMonitorTest, Basic) {
-  FireBookmarksApiEvent<RemoveBookmarkFunction>(extension1_, 1);
-  FireBookmarksApiEvent<MoveBookmarkFunction>(extension1_, 1);
-  FireBookmarksApiEvent<UpdateBookmarkFunction>(extension1_, 2);
-  FireBookmarksApiEvent<CreateBookmarkFunction>(extension1_, 3);
-  FireBookmarksApiEvent<SearchBookmarksFunction>(extension1_, 5);
+  FireBookmarksApiEvent<extensions::RemoveBookmarkFunction>(extension1_, 1);
+  FireBookmarksApiEvent<extensions::MoveBookmarkFunction>(extension1_, 1);
+  FireBookmarksApiEvent<extensions::UpdateBookmarkFunction>(extension1_, 2);
+  FireBookmarksApiEvent<extensions::CreateBookmarkFunction>(extension1_, 3);
+  FireBookmarksApiEvent<extensions::SearchBookmarksFunction>(extension1_, 5);
   const uint32 writes_by_extension1 = 1 + 1 + 2 + 3;
 
-  FireBookmarksApiEvent<RemoveTreeBookmarkFunction>(extension2_, 8);
-  FireBookmarksApiEvent<GetBookmarkTreeFunction>(extension2_, 13);
-  FireBookmarksApiEvent<GetBookmarkChildrenFunction>(extension2_, 21);
-  FireBookmarksApiEvent<GetBookmarksFunction>(extension2_, 33);
+  FireBookmarksApiEvent<extensions::RemoveTreeBookmarkFunction>(extension2_, 8);
+  FireBookmarksApiEvent<extensions::GetBookmarkTreeFunction>(extension2_, 13);
+  FireBookmarksApiEvent<extensions::GetBookmarkChildrenFunction>(
+      extension2_, 21);
+  FireBookmarksApiEvent<extensions::GetBookmarksFunction>(extension2_, 33);
   const uint32 writes_by_extension2 = 8;
 
   syncer::ExtensionsActivityMonitor::Records results;
@@ -113,8 +115,8 @@ TEST_F(SyncChromeExtensionsActivityMonitorTest, Basic) {
 // and put the old records back.  Those should be merged with the new
 // records correctly.
 TEST_F(SyncChromeExtensionsActivityMonitorTest, Put) {
-  FireBookmarksApiEvent<CreateBookmarkFunction>(extension1_, 5);
-  FireBookmarksApiEvent<MoveBookmarkFunction>(extension2_, 8);
+  FireBookmarksApiEvent<extensions::CreateBookmarkFunction>(extension1_, 5);
+  FireBookmarksApiEvent<extensions::MoveBookmarkFunction>(extension2_, 8);
 
   syncer::ExtensionsActivityMonitor::Records results;
   monitor_.GetAndClearRecords(&results);
@@ -123,8 +125,8 @@ TEST_F(SyncChromeExtensionsActivityMonitorTest, Put) {
   EXPECT_EQ(5U, results[id1_].bookmark_write_count);
   EXPECT_EQ(8U, results[id2_].bookmark_write_count);
 
-  FireBookmarksApiEvent<GetBookmarksFunction>(extension2_, 3);
-  FireBookmarksApiEvent<UpdateBookmarkFunction>(extension2_, 2);
+  FireBookmarksApiEvent<extensions::GetBookmarksFunction>(extension2_, 3);
+  FireBookmarksApiEvent<extensions::UpdateBookmarkFunction>(extension2_, 2);
 
   // Simulate a commit failure, which augments the active record set with the
   // refugee records.
@@ -143,7 +145,7 @@ TEST_F(SyncChromeExtensionsActivityMonitorTest, Put) {
 // times.  The mintor should correctly clear its records every time
 // they're returned.
 TEST_F(SyncChromeExtensionsActivityMonitorTest, MultiGet) {
-  FireBookmarksApiEvent<CreateBookmarkFunction>(extension1_, 5);
+  FireBookmarksApiEvent<extensions::CreateBookmarkFunction>(extension1_, 5);
 
   syncer::ExtensionsActivityMonitor::Records results;
   monitor_.GetAndClearRecords(&results);
@@ -154,7 +156,7 @@ TEST_F(SyncChromeExtensionsActivityMonitorTest, MultiGet) {
   monitor_.GetAndClearRecords(&results);
   EXPECT_TRUE(results.empty());
 
-  FireBookmarksApiEvent<CreateBookmarkFunction>(extension1_, 3);
+  FireBookmarksApiEvent<extensions::CreateBookmarkFunction>(extension1_, 3);
   monitor_.GetAndClearRecords(&results);
 
   EXPECT_EQ(1U, results.size());