Move ui::GetAtom to gfx::GetAtom

ui/base/x/selection_utils.cc

 // Copyright (c) 2013 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 "ui/base/x/selection_utils.h"
 
 #include <stdint.h>
 
 #include <algorithm>
 #include <set>
 
 #include "base/i18n/icu_string_conversions.h"
 #include "base/logging.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "ui/base/clipboard/clipboard.h"
-#include "ui/base/x/x11_util.h"
+#include "ui/gfx/x/x11_atom_cache.h"
 
 namespace ui {
 
 const char kString[] = "STRING";
 const char kText[] = "TEXT";
 const char kTextPlain[] = "text/plain";
 const char kTextPlainUtf8[] = "text/plain;charset=utf-8";
 const char kUtf8String[] = "UTF8_STRING";
 
 std::vector<::Atom> GetTextAtomsFrom() {
   std::vector< ::Atom> atoms;
-  atoms.push_back(GetAtom(kUtf8String));
-  atoms.push_back(GetAtom(kString));
-  atoms.push_back(GetAtom(kText));
-  atoms.push_back(GetAtom(kTextPlain));
-  atoms.push_back(GetAtom(kTextPlainUtf8));
+  atoms.push_back(gfx::GetAtom(kUtf8String));
+  atoms.push_back(gfx::GetAtom(kString));
+  atoms.push_back(gfx::GetAtom(kText));
+  atoms.push_back(gfx::GetAtom(kTextPlain));
+  atoms.push_back(gfx::GetAtom(kTextPlainUtf8));
   return atoms;
 }
 
 std::vector<::Atom> GetURLAtomsFrom() {
   std::vector< ::Atom> atoms;
-  atoms.push_back(GetAtom(Clipboard::kMimeTypeURIList));
-  atoms.push_back(GetAtom(Clipboard::kMimeTypeMozillaURL));
+  atoms.push_back(gfx::GetAtom(Clipboard::kMimeTypeURIList));
+  atoms.push_back(gfx::GetAtom(Clipboard::kMimeTypeMozillaURL));
   return atoms;
 }
 
 std::vector<::Atom> GetURIListAtomsFrom() {
   std::vector< ::Atom> atoms;
-  atoms.push_back(GetAtom(Clipboard::kMimeTypeURIList));
+  atoms.push_back(gfx::GetAtom(Clipboard::kMimeTypeURIList));
   return atoms;
 }
 
 void GetAtomIntersection(const std::vector< ::Atom>& desired,
                          const std::vector< ::Atom>& offered,
                          std::vector< ::Atom>* output) {
   for (std::vector< ::Atom>::const_iterator it = desired.begin();
        it != desired.end(); ++it) {
     std::vector< ::Atom>::const_iterator jt =
       std::find(offered.begin(), offered.end(), *it);
@@ skipping 116 matching lines @@
 
 const unsigned char* SelectionData::GetData() const {
   return memory_.get() ? memory_->front() : NULL;
 }
 
 size_t SelectionData::GetSize() const {
   return memory_.get() ? memory_->size() : 0;
 }
 
 std::string SelectionData::GetText() const {
-  if (type_ == GetAtom(kUtf8String) || type_ == GetAtom(kText) ||
-      type_ == GetAtom(kTextPlainUtf8)) {
+  if (type_ == gfx::GetAtom(kUtf8String) || type_ == gfx::GetAtom(kText) ||
+      type_ == gfx::GetAtom(kTextPlainUtf8)) {
     return RefCountedMemoryToString(memory_);
-  } else if (type_ == GetAtom(kString) || type_ == GetAtom(kTextPlain)) {
+  } else if (type_ == gfx::GetAtom(kString) ||
+             type_ == gfx::GetAtom(kTextPlain)) {
     std::string result;
     base::ConvertToUtf8AndNormalize(RefCountedMemoryToString(memory_),
                                     base::kCodepageLatin1,
                                     &result);
     return result;
   } else {
     // BTW, I looked at COMPOUND_TEXT, and there's no way we're going to
     // support that. Yuck.
     NOTREACHED();
     return std::string();
   }
 }
 
 base::string16 SelectionData::GetHtml() const {
   base::string16 markup;
 
-  if (type_ == GetAtom(Clipboard::kMimeTypeHTML)) {
+  if (type_ == gfx::GetAtom(Clipboard::kMimeTypeHTML)) {
     const unsigned char* data = GetData();
     size_t size = GetSize();
 
     // If the data starts with 0xFEFF, i.e., Byte Order Mark, assume it is
     // UTF-16, otherwise assume UTF-8.
     if (size >= 2 &&
         reinterpret_cast<const uint16_t*>(data)[0] == 0xFEFF) {
       markup.assign(reinterpret_cast<const uint16_t*>(data) + 1,
                     (size / 2) - 1);
     } else {
@@ skipping 13 matching lines @@
 
 void SelectionData::AssignTo(std::string* result) const {
   *result = RefCountedMemoryToString(memory_);
 }
 
 void SelectionData::AssignTo(base::string16* result) const {
   *result = RefCountedMemoryToString16(memory_);
 }
 
 }  // namespace ui