GTK: implement extension bookmark manager drag api....

chrome/browser/extensions/extension_bookmark_manager_api.cc

 // Copyright (c) 2010 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_bookmark_manager_api.h"
 
 #include <vector>
 
 #include "app/l10n_util.h"
 #include "base/json/json_writer.h"
 #include "base/string_util.h"
 #include "base/values.h"
 #include "chrome/browser/bookmarks/bookmark_drag_data.h"
 #include "chrome/browser/bookmarks/bookmark_model.h"
 #include "chrome/browser/bookmarks/bookmark_html_writer.h"
 #include "chrome/browser/bookmarks/bookmark_utils.h"
 #include "chrome/browser/dom_ui/chrome_url_data_manager.h"
 #include "chrome/browser/extensions/extension_bookmarks_module_constants.h"
 #include "chrome/browser/extensions/extension_dom_ui.h"
 #include "chrome/browser/extensions/extension_message_service.h"
 #include "chrome/browser/importer/importer.h"
 #include "chrome/browser/profile.h"
 #include "chrome/browser/tab_contents/tab_contents.h"
 #include "grit/generated_resources.h"
 
 namespace keys = extension_bookmarks_module_constants;
 
 namespace {
 
-typedef RenderViewHostDelegate::BookmarkDrag::DragData DragData;
-
 // Returns a single bookmark node from the argument ID.
 // This returns NULL in case of failure.
 const BookmarkNode* GetNodeFromArguments(BookmarkModel* model,
     const Value* args) {
   std::string id_string;
   if (!args->GetAsString(&id_string))
     return NULL;
   int64 id;
   if (!StringToInt64(id_string, &id))
     return NULL;
@@ skipping 87 matching lines @@
     // We do not have an node IDs when the data comes from a different profile.
     std::vector<BookmarkDragData::Element> elements = data.elements;
     for (size_t i = 0; i < elements.size(); ++i)
       AddElementToList(list, elements[i]);
   }
   value->Set(keys::kElementsKey, list);
 
   args->Append(value);
 }
 
-// This is the platform specific function that takes the drag data and creates
-// the BookmarkDragData as needed.
-bool GetBookmarkDragData(const DragData* data,
-                         BookmarkDragData* bookmark_drag_data) {
-#if defined(TOOLKIT_VIEWS)
-  // On TOOLKIT_VIEWS DragData is OSExchangeData.
-  return bookmark_drag_data->Read(*data);
-#elif defined(OS_MACOSX)
-  return bookmark_drag_data->ReadFromDragClipboard();
-#else
-  NOTIMPLEMENTED();
-  return false;
-#endif
-}
-
 }  // namespace
 
 ExtensionBookmarkManagerEventRouter::ExtensionBookmarkManagerEventRouter(
     Profile* profile, TabContents* tab_contents)
     : profile_(profile),
     tab_contents_(tab_contents) {
   tab_contents_->SetBookmarkDragDelegate(this);
 }
 
 ExtensionBookmarkManagerEventRouter::~ExtensionBookmarkManagerEventRouter() {
   if (tab_contents_->GetBookmarkDragDelegate() == this)
     tab_contents_->SetBookmarkDragDelegate(NULL);
 }
 
 void ExtensionBookmarkManagerEventRouter::DispatchEvent(const char* event_name,
                                                         const ListValue* args) {
   if (!profile_->GetExtensionMessageService())
     return;
 
   std::string json_args;
   base::JSONWriter::Write(args, false, &json_args);
   profile_->GetExtensionMessageService()->DispatchEventToRenderers(
       event_name, json_args, profile_->IsOffTheRecord());
 }
 
 void ExtensionBookmarkManagerEventRouter::DispatchDragEvent(
-    const DragData* data, const char* event_name) {
-  BookmarkDragData bookmark_drag_data;
-  if (::GetBookmarkDragData(data, &bookmark_drag_data)) {
-    ListValue args;
-    BookmarkDragDataToJSON(profile_, bookmark_drag_data, &args);
-    DispatchEvent(event_name, &args);
-  }
+    const BookmarkDragData& data, const char* event_name) {
+  if (data.size() == 0)
+    return;
+
+  ListValue args;
+  BookmarkDragDataToJSON(profile_, data, &args);
+  DispatchEvent(event_name, &args);
 }
 
-void ExtensionBookmarkManagerEventRouter::OnDragEnter(const DragData* data) {
+void ExtensionBookmarkManagerEventRouter::OnDragEnter(
+    const BookmarkDragData& data) {
   DispatchDragEvent(data, keys::kOnBookmarkDragEnter);
 }
 
-void ExtensionBookmarkManagerEventRouter::OnDragOver(const DragData* data) {
+void ExtensionBookmarkManagerEventRouter::OnDragOver(
+    const BookmarkDragData& 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(const DragData* data) {
+void ExtensionBookmarkManagerEventRouter::OnDragLeave(
+    const BookmarkDragData& data) {
   DispatchDragEvent(data, keys::kOnBookmarkDragLeave);
 }
 
-void ExtensionBookmarkManagerEventRouter::OnDrop(const DragData* data) {
+void ExtensionBookmarkManagerEventRouter::OnDrop(
+    const BookmarkDragData& data) {
   DispatchDragEvent(data, keys::kOnBookmarkDrop);
 
   // Make a copy that is owned by this instance.
   ClearBookmarkDragData();
-  ::GetBookmarkDragData(data, &bookmark_drag_data_);
+  bookmark_drag_data_ = data;
 }
 
 const BookmarkDragData*
 ExtensionBookmarkManagerEventRouter::GetBookmarkDragData() {
   if (bookmark_drag_data_.is_valid())
     return &bookmark_drag_data_;
   return NULL;
 }
 
 void ExtensionBookmarkManagerEventRouter::ClearBookmarkDragData() {
@@ skipping 231 matching lines @@
 
   DCHECK(router);
 
   bookmark_utils::PerformBookmarkDrop(profile(), *router->GetBookmarkDragData(),
                                       drop_parent, drop_index);
 
   router->ClearBookmarkDragData();
   SendResponse(true);
   return true;
 }