Move more dnd related files to ui/base

chrome/browser/ui/gtk/bookmark_utils_gtk.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/gtk/bookmark_utils_gtk.h"
 
-#include "app/gtk_dnd_util.h"
 #include "app/l10n_util.h"
 #include "app/resource_bundle.h"
 #include "base/pickle.h"
 #include "base/string16.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/bookmarks/bookmark_node_data.h"
 #include "chrome/browser/bookmarks/bookmark_model.h"
 #include "chrome/browser/bookmarks/bookmark_utils.h"
 #include "chrome/browser/gtk/gtk_chrome_button.h"
 #include "chrome/browser/gtk/gtk_theme_provider.h"
 #include "chrome/browser/gtk/gtk_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "gfx/canvas_skia_paint.h"
 #include "gfx/font.h"
 #include "gfx/gtk_util.h"
+#include "ui/base/dragdrop/gtk_dnd_util.h"
 
 namespace {
 
 // Spacing between the favicon and the text.
 const int kBarButtonPadding = 4;
 
 // Used in gtk_selection_data_set(). (I assume from this parameter that gtk has
 // to some really exotic hardware...)
 const int kBitsInAByte = 8;
 
@@ skipping 253 matching lines @@
     // Because the prelight state is a white image that doesn't change by the
     // theme, force the text color to black when it would be used.
     gtk_widget_modify_fg(label, GTK_STATE_ACTIVE, &gtk_util::kGdkBlack);
     gtk_widget_modify_fg(label, GTK_STATE_PRELIGHT, &gtk_util::kGdkBlack);
   }
 }
 
 // DnD-related -----------------------------------------------------------------
 
 int GetCodeMask(bool folder) {
-  int rv = gtk_dnd_util::CHROME_BOOKMARK_ITEM;
+  int rv = ui::CHROME_BOOKMARK_ITEM;
   if (!folder) {
-    rv |= gtk_dnd_util::TEXT_URI_LIST |
-          gtk_dnd_util::TEXT_PLAIN |
-          gtk_dnd_util::NETSCAPE_URL;
+    rv |= ui::TEXT_URI_LIST |
+          ui::TEXT_PLAIN |
+          ui::NETSCAPE_URL;
   }
   return rv;
 }
 
 void WriteBookmarkToSelection(const BookmarkNode* node,
                               GtkSelectionData* selection_data,
                               guint target_type,
                               Profile* profile) {
   DCHECK(node);
   std::vector<const BookmarkNode*> nodes;
   nodes.push_back(node);
   WriteBookmarksToSelection(nodes, selection_data, target_type, profile);
 }
 
 void WriteBookmarksToSelection(const std::vector<const BookmarkNode*>& nodes,
                                GtkSelectionData* selection_data,
                                guint target_type,
                                Profile* profile) {
   switch (target_type) {
-    case gtk_dnd_util::CHROME_BOOKMARK_ITEM: {
+    case ui::CHROME_BOOKMARK_ITEM: {
       BookmarkNodeData data(nodes);
       Pickle pickle;
       data.WriteToPickle(profile, &pickle);
 
       gtk_selection_data_set(selection_data, selection_data->target,
                              kBitsInAByte,
                              static_cast<const guchar*>(pickle.data()),
                              pickle.size());
       break;
     }
-    case gtk_dnd_util::NETSCAPE_URL: {
+    case ui::NETSCAPE_URL: {
       // _NETSCAPE_URL format is URL + \n + title.
       std::string utf8_text = nodes[0]->GetURL().spec() + "\n" +
           UTF16ToUTF8(nodes[0]->GetTitle());
       gtk_selection_data_set(selection_data,
                              selection_data->target,
                              kBitsInAByte,
                              reinterpret_cast<const guchar*>(utf8_text.c_str()),
                              utf8_text.length());
       break;
     }
-    case gtk_dnd_util::TEXT_URI_LIST: {
+    case ui::TEXT_URI_LIST: {
       gchar** uris = reinterpret_cast<gchar**>(malloc(sizeof(gchar*) *
                                                (nodes.size() + 1)));
       for (size_t i = 0; i < nodes.size(); ++i) {
         // If the node is a folder, this will be empty. TODO(estade): figure out
         // if there are any ramifications to passing an empty URI. After a
         // little testing, it seems fine.
         const GURL& url = nodes[i]->GetURL();
         // This const cast should be safe as gtk_selection_data_set_uris()
         // makes copies.
         uris[i] = const_cast<gchar*>(url.spec().c_str());
       }
       uris[nodes.size()] = NULL;
 
       gtk_selection_data_set_uris(selection_data, uris);
       free(uris);
       break;
     }
-    case gtk_dnd_util::TEXT_PLAIN: {
+    case ui::TEXT_PLAIN: {
       gtk_selection_data_set_text(selection_data,
                                   nodes[0]->GetURL().spec().c_str(), -1);
       break;
     }
     default: {
       DLOG(ERROR) << "Unsupported drag get type!";
     }
   }
 }
 
 std::vector<const BookmarkNode*> GetNodesFromSelection(
     GdkDragContext* context,
     GtkSelectionData* selection_data,
     guint target_type,
     Profile* profile,
     gboolean* delete_selection_data,
     gboolean* dnd_success) {
   if (delete_selection_data)
     *delete_selection_data = FALSE;
   if (dnd_success)
     *dnd_success = FALSE;
 
   if (selection_data && selection_data->length > 0) {
     if (context && delete_selection_data && context->action == GDK_ACTION_MOVE)
       *delete_selection_data = TRUE;
 
     switch (target_type) {
-      case gtk_dnd_util::CHROME_BOOKMARK_ITEM: {
+      case ui::CHROME_BOOKMARK_ITEM: {
         if (dnd_success)
           *dnd_success = TRUE;
         Pickle pickle(reinterpret_cast<char*>(selection_data->data),
                       selection_data->length);
         BookmarkNodeData drag_data;
         drag_data.ReadFromPickle(&pickle);
         return drag_data.GetNodes(profile);
       }
       default: {
         DLOG(ERROR) << "Unsupported drag received type: " << target_type;
       }
     }
   }
 
   return std::vector<const BookmarkNode*>();
 }
 
 bool CreateNewBookmarkFromNamedUrl(GtkSelectionData* selection_data,
     BookmarkModel* model, const BookmarkNode* parent, int idx) {
   GURL url;
   string16 title;
-  if (!gtk_dnd_util::ExtractNamedURL(selection_data, &url, &title))
+  if (!ui::ExtractNamedURL(selection_data, &url, &title))
     return false;
 
   model->AddURL(parent, idx, title, url);
   return true;
 }
 
 bool CreateNewBookmarksFromURIList(GtkSelectionData* selection_data,
     BookmarkModel* model, const BookmarkNode* parent, int idx) {
   std::vector<GURL> urls;
-  gtk_dnd_util::ExtractURIList(selection_data, &urls);
+  ui::ExtractURIList(selection_data, &urls);
   for (size_t i = 0; i < urls.size(); ++i) {
     std::string title = GetNameForURL(urls[i]);
     model->AddURL(parent, idx++, UTF8ToUTF16(title), urls[i]);
   }
   return true;
 }
 
 bool CreateNewBookmarkFromNetscapeURL(GtkSelectionData* selection_data,
     BookmarkModel* model, const BookmarkNode* parent, int idx) {
   GURL url;
   string16 title;
-  if (!gtk_dnd_util::ExtractNetscapeURL(selection_data, &url, &title))
+  if (!ui::ExtractNetscapeURL(selection_data, &url, &title))
     return false;
 
   model->AddURL(parent, idx, title, url);
   return true;
 }
 
 }  // namespace bookmark_utils