Move more dnd related files to ui/base

chrome/browser/tab_contents/web_drag_dest_gtk.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/tab_contents/web_drag_dest_gtk.h"
 
 #include <string>
 
-#include "app/gtk_dnd_util.h"
 #include "base/file_path.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/bookmarks/bookmark_node_data.h"
 #include "chrome/browser/gtk/bookmark_utils_gtk.h"
 #include "chrome/browser/gtk/gtk_util.h"
 #include "chrome/browser/renderer_host/render_view_host.h"
 #include "chrome/browser/tab_contents/tab_contents.h"
 #include "chrome/common/url_constants.h"
 #include "net/base/net_util.h"
+#include "ui/base/dragdrop/gtk_dnd_util.h"
 
 using WebKit::WebDragOperation;
 using WebKit::WebDragOperationNone;
 
 namespace {
 
 // Returns the bookmark target atom, based on the underlying toolkit.
 //
 // For GTK, bookmark drag data is encoded as pickle and associated with
-// gtk_dnd_util::CHROME_BOOKMARK_ITEM. See
-// bookmark_utils::WriteBookmarksToSelection() for details.
+// ui::CHROME_BOOKMARK_ITEM. See // bookmark_utils::WriteBookmarksToSelection()
+// for details.
 // For Views, bookmark drag data is encoded in the same format, and
 // associated with a custom format. See BookmarkNodeData::Write() for
 // details.
 GdkAtom GetBookmarkTargetAtom() {
 #if defined(TOOLKIT_VIEWS)
   return BookmarkNodeData::GetBookmarkCustomFormat();
 #else
-  return gtk_dnd_util::GetAtomForTarget(gtk_dnd_util::CHROME_BOOKMARK_ITEM);
+  return ui::GetAtomForTarget(ui::CHROME_BOOKMARK_ITEM);
 #endif
 }
 
 }  // namespace
 
 WebDragDestGtk::WebDragDestGtk(TabContents* tab_contents, GtkWidget* widget)
     : tab_contents_(tab_contents),
       widget_(widget),
       context_(NULL),
       method_factory_(this) {
@@ skipping 49 matching lines @@
     drop_data_.reset(new WebDropData);
     bookmark_drag_data_.Clear();
     is_drop_target_ = false;
 
     // text/plain must come before text/uri-list. This is a hack that works in
     // conjunction with OnDragDataReceived. Since some file managers populate
     // text/plain with file URLs when dragging files, we want to handle
     // text/uri-list after text/plain so that the plain text can be cleared if
     // it's a file drag.
     static int supported_targets[] = {
-      gtk_dnd_util::TEXT_PLAIN,
-      gtk_dnd_util::TEXT_URI_LIST,
-      gtk_dnd_util::TEXT_HTML,
-      gtk_dnd_util::NETSCAPE_URL,
-      gtk_dnd_util::CHROME_NAMED_URL,
+      ui::TEXT_PLAIN,
+      ui::TEXT_URI_LIST,
+      ui::TEXT_HTML,
+      ui::NETSCAPE_URL,
+      ui::CHROME_NAMED_URL,
       // TODO(estade): support image drags?
     };
 
     // Add the bookmark target as well.
     data_requests_ = arraysize(supported_targets) + 1;
     for (size_t i = 0; i < arraysize(supported_targets); ++i) {
       gtk_drag_get_data(widget_, context,
-                        gtk_dnd_util::GetAtomForTarget(supported_targets[i]),
+                        ui::GetAtomForTarget(supported_targets[i]),
                         time);
     }
 
     gtk_drag_get_data(widget_, context, GetBookmarkTargetAtom(), time);
   } else if (data_requests_ == 0) {
     tab_contents_->render_view_host()->
         DragTargetDragOver(
             gtk_util::ClientPoint(widget_),
             gtk_util::ScreenPoint(widget_),
             gtk_util::GdkDragActionToWebDragOp(context->actions));
@@ skipping 14 matching lines @@
   // care about.
   if (context != context_)
     return;
 
   data_requests_--;
 
   // Decode the data.
   if (data->data && data->length > 0) {
     // If the source can't provide us with valid data for a requested target,
     // data->data will be NULL.
-    if (data->target ==
-        gtk_dnd_util::GetAtomForTarget(gtk_dnd_util::TEXT_PLAIN)) {
+    if (data->target == ui::GetAtomForTarget(ui::TEXT_PLAIN)) {
       guchar* text = gtk_selection_data_get_text(data);
       if (text) {
         drop_data_->plain_text =
             UTF8ToUTF16(std::string(reinterpret_cast<char*>(text),
                                     data->length));
         g_free(text);
       }
-    } else if (data->target ==
-               gtk_dnd_util::GetAtomForTarget(gtk_dnd_util::TEXT_URI_LIST)) {
+    } else if (data->target == ui::GetAtomForTarget(ui::TEXT_URI_LIST)) {
       gchar** uris = gtk_selection_data_get_uris(data);
       if (uris) {
         drop_data_->url = GURL();
         for (gchar** uri_iter = uris; *uri_iter; uri_iter++) {
           // Most file managers populate text/uri-list with file URLs when
           // dragging files. To avoid exposing file system paths to web content,
           // file URLs are never set as the URL content for the drop.
           // TODO(estade): Can the filenames have a non-UTF8 encoding?
           GURL url(*uri_iter);
           FilePath file_path;
           if (url.SchemeIs(chrome::kFileScheme) &&
               net::FileURLToFilePath(url, &file_path)) {
             drop_data_->filenames.push_back(UTF8ToUTF16(file_path.value()));
             // This is a hack. Some file managers also populate text/plain with
             // a file URL when dragging files, so we clear it to avoid exposing
             // it to the web content.
             drop_data_->plain_text.clear();
           } else if (!drop_data_->url.is_valid()) {
             // Also set the first non-file URL as the URL content for the drop.
             drop_data_->url = url;
           }
         }
         g_strfreev(uris);
       }
-    } else if (data->target ==
-               gtk_dnd_util::GetAtomForTarget(gtk_dnd_util::TEXT_HTML)) {
+    } else if (data->target == ui::GetAtomForTarget(ui::TEXT_HTML)) {
       // TODO(estade): Can the html have a non-UTF8 encoding?
       drop_data_->text_html =
           UTF8ToUTF16(std::string(reinterpret_cast<char*>(data->data),
                                   data->length));
       // We leave the base URL empty.
-    } else if (data->target ==
-               gtk_dnd_util::GetAtomForTarget(gtk_dnd_util::NETSCAPE_URL)) {
+    } else if (data->target == ui::GetAtomForTarget(ui::NETSCAPE_URL)) {
       std::string netscape_url(reinterpret_cast<char*>(data->data),
                                data->length);
       size_t split = netscape_url.find_first_of('\n');
       if (split != std::string::npos) {
         drop_data_->url = GURL(netscape_url.substr(0, split));
         if (split < netscape_url.size() - 1)
           drop_data_->url_title = UTF8ToUTF16(netscape_url.substr(split + 1));
       }
-    } else if (data->target ==
-               gtk_dnd_util::GetAtomForTarget(gtk_dnd_util::CHROME_NAMED_URL)) {
-      gtk_dnd_util::ExtractNamedURL(data,
-                                    &drop_data_->url, &drop_data_->url_title);
+    } else if (data->target == ui::GetAtomForTarget(ui::CHROME_NAMED_URL)) {
+      ui::ExtractNamedURL(data, &drop_data_->url, &drop_data_->url_title);
     }
   }
 
   // For CHROME_BOOKMARK_ITEM, we have to handle the case where the drag source
   // doesn't have any data available for us. In this case we try to synthesize a
   // URL bookmark.
   // Note that bookmark drag data is encoded in the same format for both
   // GTK and Views, hence we can share the same logic here.
   if (data->target == GetBookmarkTargetAtom()) {
     if (data->data && data->length > 0) {
       bookmark_drag_data_.ReadFromVector(
           bookmark_utils::GetNodesFromSelection(
               NULL, data,
-              gtk_dnd_util::CHROME_BOOKMARK_ITEM,
+              ui::CHROME_BOOKMARK_ITEM,
               tab_contents_->profile(), NULL, NULL));
       bookmark_drag_data_.SetOriginatingProfile(tab_contents_->profile());
     } else {
       bookmark_drag_data_.ReadFromTuple(drop_data_->url,
                                         drop_data_->url_title);
     }
   }
 
   if (data_requests_ == 0) {
     // Tell the renderer about the drag.
@@ skipping 44 matching lines @@
   // support for (at the moment experimental) drag and drop extensions.
   if (tab_contents_->GetBookmarkDragDelegate())
     tab_contents_->GetBookmarkDragDelegate()->OnDrop(bookmark_drag_data_);
 
   // The second parameter is just an educated guess as to whether or not the
   // drag succeeded, but at least we will get the drag-end animation right
   // sometimes.
   gtk_drag_finish(context, is_drop_target_, FALSE, time);
   return TRUE;
 }