bookmarks: Rename ExtensionBookmarkManagerEventRouter.

chrome/browser/bookmarks/bookmark_manager_extension_api.cc

 // Copyright (c) 2011 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 <vector>
 
 #include "base/json/json_writer.h"
 #include "base/string_number_conversions.h"
@@ skipping 128 matching lines @@
     for (size_t i = 0; i < elements.size(); ++i)
       AddElementToList(list, elements[i]);
   }
   value->Set(keys::kElementsKey, list);
 
   args->Append(value);
 }
 
 }  // namespace
 
-ExtensionBookmarkManagerEventRouter::ExtensionBookmarkManagerEventRouter(
+BookmarkManagerExtensionEventRouter::BookmarkManagerExtensionEventRouter(
     Profile* profile, TabContentsWrapper* tab)
     : profile_(profile),
     tab_(tab) {
   tab_->bookmark_tab_helper()->SetBookmarkDragDelegate(this);
 }
 
-ExtensionBookmarkManagerEventRouter::~ExtensionBookmarkManagerEventRouter() {
+BookmarkManagerExtensionEventRouter::~BookmarkManagerExtensionEventRouter() {
   if (tab_->bookmark_tab_helper()->GetBookmarkDragDelegate() == this)
     tab_->bookmark_tab_helper()->SetBookmarkDragDelegate(NULL);
 }
 
-void ExtensionBookmarkManagerEventRouter::DispatchEvent(const char* event_name,
+void BookmarkManagerExtensionEventRouter::DispatchEvent(const char* event_name,
                                                         const ListValue* args) {
   if (!profile_->GetExtensionEventRouter())
     return;
 
   std::string json_args;
   base::JSONWriter::Write(args, false, &json_args);
   profile_->GetExtensionEventRouter()->DispatchEventToRenderers(
       event_name, json_args, NULL, GURL());
 }
 
-void ExtensionBookmarkManagerEventRouter::DispatchDragEvent(
+void BookmarkManagerExtensionEventRouter::DispatchDragEvent(
     const BookmarkNodeData& data, const char* event_name) {
   if (data.size() == 0)
     return;
 
   ListValue args;
   BookmarkNodeDataToJSON(profile_, data, &args);
   DispatchEvent(event_name, &args);
 }
 
-void ExtensionBookmarkManagerEventRouter::OnDragEnter(
+void BookmarkManagerExtensionEventRouter::OnDragEnter(
     const BookmarkNodeData& data) {
   DispatchDragEvent(data, keys::kOnBookmarkDragEnter);
 }
 
-void ExtensionBookmarkManagerEventRouter::OnDragOver(
+void BookmarkManagerExtensionEventRouter::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 ExtensionBookmarkManagerEventRouter::OnDragLeave(
+void BookmarkManagerExtensionEventRouter::OnDragLeave(
     const BookmarkNodeData& data) {
   DispatchDragEvent(data, keys::kOnBookmarkDragLeave);
 }
 
-void ExtensionBookmarkManagerEventRouter::OnDrop(
+void BookmarkManagerExtensionEventRouter::OnDrop(
     const BookmarkNodeData& data) {
   DispatchDragEvent(data, keys::kOnBookmarkDrop);
 
   // Make a copy that is owned by this instance.
   ClearBookmarkNodeData();
   bookmark_drag_data_ = data;
 }
 
 const BookmarkNodeData*
-ExtensionBookmarkManagerEventRouter::GetBookmarkNodeData() {
+BookmarkManagerExtensionEventRouter::GetBookmarkNodeData() {
   if (bookmark_drag_data_.is_valid())
     return &bookmark_drag_data_;
   return NULL;
 }
 
-void ExtensionBookmarkManagerEventRouter::ClearBookmarkNodeData() {
+void BookmarkManagerExtensionEventRouter::ClearBookmarkNodeData() {
   bookmark_drag_data_.Clear();
 }
 
 bool ClipboardBookmarkManagerFunction::CopyOrCut(bool cut) {
   BookmarkModel* model = profile()->GetBookmarkModel();
   std::vector<const BookmarkNode*> nodes;
   EXTENSION_FUNCTION_VALIDATE(GetNodesFromArguments(model, args_.get(),
                                                     0, &nodes));
   bookmark_utils::CopyToClipboard(model, nodes, cut);
   return true;
@@ skipping 188 matching lines @@
     drop_index = drop_parent->child_count();
 
   if (render_view_host_->delegate()->GetRenderViewType() ==
       content::VIEW_TYPE_TAB_CONTENTS) {
     TabContents* tab_contents =
         dispatcher()->delegate()->GetAssociatedTabContents();
     CHECK(tab_contents);
     ExtensionWebUI* web_ui =
         static_cast<ExtensionWebUI*>(tab_contents->web_ui());
     CHECK(web_ui);
-    ExtensionBookmarkManagerEventRouter* router =
-        web_ui->extension_bookmark_manager_event_router();
+    BookmarkManagerExtensionEventRouter* router =
+        web_ui->bookmark_manager_extension_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 43 matching lines @@
 bool CanEditBookmarkManagerFunction::RunImpl() {
   result_.reset(Value::CreateBooleanValue(
       profile_->GetPrefs()->GetBoolean(prefs::kEditBookmarksEnabled)));
   return true;
 }
 
 bool RecordLaunchBookmarkFunction::RunImpl() {
   bookmark_utils::RecordBookmarkLaunch(bookmark_utils::LAUNCH_MANAGER);
   return true;
 }