content: Split web_drag_dest_gtk.cc into chrome/ and content/ parts.

chrome/browser/bookmarks/bookmark_node_data.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_node_data.h"
 
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/pickle.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/bookmarks/bookmark_model.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/url_constants.h"
 #include "net/base/escape.h"
 #include "ui/base/clipboard/scoped_clipboard_writer.h"
+#include "ui/base/dragdrop/bookmark_format.h"
 
 #if defined(OS_MACOSX)
 #include "chrome/browser/bookmarks/bookmark_pasteboard_helper_mac.h"
 #else
 #include "chrome/browser/browser_process.h"
 #endif
 
-const char* BookmarkNodeData::kClipboardFormatString =
-    "chromium/x-bookmark-entries";
-
 BookmarkNodeData::Element::Element() : is_url(false), id_(0) {
 }
 
 BookmarkNodeData::Element::Element(const BookmarkNode* node)
     : is_url(node->is_url()),
       url(node->url()),
       title(node->GetTitle()),
       id_(node->id()) {
   for (int i = 0; i < node->child_count(); ++i)
     children.push_back(Element(node->GetChild(i)));
@@ skipping 34 matching lines @@
     children.resize(children_count);
     for (std::vector<Element>::iterator i = children.begin();
          i != children.end(); ++i) {
       if (!i->ReadFromPickle(pickle, iterator))
         return false;
     }
   }
   return true;
 }
 
-#if defined(TOOLKIT_VIEWS)
-// static
-ui::OSExchangeData::CustomFormat BookmarkNodeData::GetBookmarkCustomFormat() {
-  static ui::OSExchangeData::CustomFormat format;
-  static bool format_valid = false;
-
-  if (!format_valid) {
-    format_valid = true;
-    format = ui::OSExchangeData::RegisterCustomFormat(
-        BookmarkNodeData::kClipboardFormatString);
-  }
-  return format;
-}
-#endif
-
 BookmarkNodeData::BookmarkNodeData() {
 }
 
 BookmarkNodeData::BookmarkNodeData(const BookmarkNode* node) {
   elements.push_back(Element(node));
 }
 
 BookmarkNodeData::BookmarkNodeData(
     const std::vector<const BookmarkNode*>& nodes) {
   ReadFromVector(nodes);
@@ skipping 47 matching lines @@
     // Also write the URL to the clipboard as text so that it can be pasted
     // into text fields. We use WriteText instead of WriteURL because we don't
     // want to clobber the X clipboard when the user copies out of the omnibox
     // on Linux (on Windows and Mac, there is no difference between these
     // functions).
     scw.WriteText(UTF8ToUTF16(url));
   }
 
   Pickle pickle;
   WriteToPickle(profile, &pickle);
-  scw.WritePickledData(pickle, kClipboardFormatString);
+  scw.WritePickledData(pickle, ui::kClipboardFormatString);
 }
 
 bool BookmarkNodeData::ReadFromClipboard() {
   std::string data;
   ui::Clipboard* clipboard = g_browser_process->clipboard();
-  clipboard->ReadData(kClipboardFormatString, &data);
+  clipboard->ReadData(ui::kClipboardFormatString, &data);
 
   if (!data.empty()) {
     Pickle pickle(data.data(), data.size());
     if (ReadFromPickle(&pickle))
       return true;
   }
 
   string16 title;
   std::string url;
   clipboard->ReadBookmark(&title, &url);
@@ skipping 12 matching lines @@
 }
 
 bool BookmarkNodeData::ClipboardContainsBookmarks() {
 #if defined(TOUCH_UI)
   // Temporarily disabling clipboard due to bug 96448.
   // TODO(wyck): Reenable when cause of message loop hang in
   // gtk_clipboard_wait_for_contents is determined and fixed.
   return false;
 #else
   return g_browser_process->clipboard()->IsFormatAvailableByString(
-      BookmarkNodeData::kClipboardFormatString, ui::Clipboard::BUFFER_STANDARD);
+      ui::kClipboardFormatString, ui::Clipboard::BUFFER_STANDARD);
 #endif
 }
 #else
 void BookmarkNodeData::WriteToClipboard(Profile* profile) const {
   bookmark_pasteboard_helper_mac::WriteToClipboard(elements,
                                                    profile_path_.value());
 }
 
 bool BookmarkNodeData::ReadFromClipboard() {
   // TODO(evan): bookmark_pasteboard_helper_mac should just use FilePaths.
@@ skipping 28 matching lines @@
     if (elements[0].url.SchemeIs(chrome::kJavaScriptScheme)) {
       data->SetString(UTF8ToUTF16(elements[0].url.spec()));
     } else {
       data->SetURL(elements[0].url, elements[0].title);
     }
   }
 
   Pickle data_pickle;
   WriteToPickle(profile, &data_pickle);
 
-  data->SetPickledData(GetBookmarkCustomFormat(), data_pickle);
+  data->SetPickledData(ui::GetBookmarkCustomFormat(), data_pickle);
 }
 
 bool BookmarkNodeData::Read(const ui::OSExchangeData& data) {
   elements.clear();
 
   profile_path_.clear();
 
-  if (data.HasCustomFormat(GetBookmarkCustomFormat())) {
+  if (data.HasCustomFormat(ui::GetBookmarkCustomFormat())) {
     Pickle drag_data_pickle;
-    if (data.GetPickledData(GetBookmarkCustomFormat(), &drag_data_pickle)) {
+    if (data.GetPickledData(ui::GetBookmarkCustomFormat(), &drag_data_pickle)) {
       if (!ReadFromPickle(&drag_data_pickle))
         return false;
     }
   } else {
     // See if there is a URL on the clipboard.
     Element element;
     GURL url;
     string16 title;
     if (data.GetURLAndTitle(&url, &title))
       ReadFromTuple(url, title);
@@ skipping 63 matching lines @@
   DCHECK(profile_path_.empty());
 
   if (profile)
     profile_path_ = profile->GetPath();
 }
 
 bool BookmarkNodeData::IsFromProfile(Profile* profile) const {
   // An empty path means the data is not associated with any profile.
   return !profile_path_.empty() && profile_path_ == profile->GetPath();
 }