Make selection_owner.h not include Xlib.h for consistency with

selection_requestor.h

BUG=367549
TEST=None
R=derat
TBR=dcheng,sky (for trivial changes to clipboard_aurax11.cc and os_exchange_data_provider_aurax11.cc)

Review URL: https://codereview.chromium.org/396813004

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@283825 0039d316-1c4b-4281-b951-d872f2087c98

ui/base/clipboard/clipboard_aurax11.cc

@@ -534,12 +534,12 @@ uint32_t Clipboard::AuraX11Details::DispatchEvent(const PlatformEvent& xev) {
   switch (xev->type) {
     case SelectionRequest: {
       if (xev->xselectionrequest.selection == XA_PRIMARY) {
-        primary_owner_.OnSelectionRequest(xev->xselectionrequest);
+        primary_owner_.OnSelectionRequest(*xev);
       } else {
         // We should not get requests for the CLIPBOARD_MANAGER selection
         // because we never take ownership of it.
         DCHECK_EQ(GetCopyPasteSelection(), xev->xselectionrequest.selection);
-        clipboard_owner_.OnSelectionRequest(xev->xselectionrequest);
+        clipboard_owner_.OnSelectionRequest(*xev);
       }
       break;
     }
@@ -555,12 +555,12 @@ uint32_t Clipboard::AuraX11Details::DispatchEvent(const PlatformEvent& xev) {
     }
     case SelectionClear: {
       if (xev->xselectionclear.selection == XA_PRIMARY) {
-        primary_owner_.OnSelectionClear(xev->xselectionclear);
+        primary_owner_.OnSelectionClear(*xev);
       } else {
         // We should not get requests for the CLIPBOARD_MANAGER selection
         // because we never take ownership of it.
         DCHECK_EQ(GetCopyPasteSelection(), xev->xselection.selection);
-        clipboard_owner_.OnSelectionClear(xev->xselectionclear);
+        clipboard_owner_.OnSelectionClear(*xev);
         }
       break;
     }

ui/base/dragdrop/os_exchange_data_provider_aurax11.cc

@@ -517,7 +517,7 @@ uint32_t OSExchangeDataProviderAuraX11::DispatchEvent(
   XEvent* xev = event;
   switch (xev->type) {
     case SelectionRequest:
-      selection_owner_.OnSelectionRequest(xev->xselectionrequest);
+      selection_owner_.OnSelectionRequest(*xev);
       return ui::POST_DISPATCH_STOP_PROPAGATION;
     default:
       NOTIMPLEMENTED();

ui/base/x/selection_owner.cc

@@ -31,9 +31,9 @@ const char* kAtomsToCache[] = {
 // Gets the value of an atom pair array property. On success, true is returned
 // and the value is stored in |value|.
 bool GetAtomPairArrayProperty(XID window,
-                              Atom property,
-                              std::vector<std::pair<Atom,Atom> >* value) {
-  Atom type = None;
+                              XAtom property,
+                              std::vector<std::pair<XAtom,XAtom> >* value) {
+  XAtom type = None;
   int format = 0;  // size in bits of each item in 'property'
   unsigned long num_items = 0;
   unsigned char* properties = NULL;
@@ -62,7 +62,7 @@ bool GetAtomPairArrayProperty(XID window,
     return false;
   }
 
-  Atom* atom_properties = reinterpret_cast<Atom*>(properties);
+  XAtom* atom_properties = reinterpret_cast<XAtom*>(properties);
   value->clear();
   for (size_t i = 0; i < num_items; i+=2)
     value->push_back(std::make_pair(atom_properties[i], atom_properties[i+1]));
@@ -72,9 +72,9 @@ bool GetAtomPairArrayProperty(XID window,
 
 }  // namespace
 
-SelectionOwner::SelectionOwner(Display* x_display,
-                               Window x_window,
-                               Atom selection_name)
+SelectionOwner::SelectionOwner(XDisplay* x_display,
+                               XID x_window,
+                               XAtom selection_name)
     : x_display_(x_display),
       x_window_(x_window),
       selection_name_(selection_name),
@@ -89,7 +89,7 @@ SelectionOwner::~SelectionOwner() {
     XSetSelectionOwner(x_display_, selection_name_, None, CurrentTime);
 }
 
-void SelectionOwner::RetrieveTargets(std::vector<Atom>* targets) {
+void SelectionOwner::RetrieveTargets(std::vector<XAtom>* targets) {
   for (SelectionFormatMap::const_iterator it = format_map_.begin();
        it != format_map_.end(); ++it) {
     targets->push_back(it->first);
@@ -111,28 +111,32 @@ void SelectionOwner::ClearSelectionOwner() {
   format_map_ = SelectionFormatMap();
 }
 
-void SelectionOwner::OnSelectionRequest(const XSelectionRequestEvent& event) {
+void SelectionOwner::OnSelectionRequest(const XEvent& event) {
+  XID requestor = event.xselectionrequest.requestor;
+  XAtom requested_target = event.xselectionrequest.target;
+  XAtom requested_property = event.xselectionrequest.property;
+
   // Incrementally build our selection. By default this is a refusal, and we'll
   // override the parts indicating success in the different cases.
   XEvent reply;
   reply.xselection.type = SelectionNotify;
-  reply.xselection.requestor = event.requestor;
-  reply.xselection.selection = event.selection;
-  reply.xselection.target = event.target;
+  reply.xselection.requestor = requestor;
+  reply.xselection.selection = event.xselectionrequest.selection;
+  reply.xselection.target = requested_target;
   reply.xselection.property = None;  // Indicates failure
-  reply.xselection.time = event.time;
+  reply.xselection.time = event.xselectionrequest.time;
 
-  if (event.target == atom_cache_.GetAtom(kMultiple)) {
-    // The contents of |event.property| should be a list of
+  if (requested_target == atom_cache_.GetAtom(kMultiple)) {
+    // The contents of |requested_property| should be a list of
     // <target,property> pairs.
-    std::vector<std::pair<Atom,Atom> > conversions;
-    if (GetAtomPairArrayProperty(event.requestor,
-                                 event.property,
+    std::vector<std::pair<XAtom,XAtom> > conversions;
+    if (GetAtomPairArrayProperty(requestor,
+                                 requested_property,
                                  &conversions)) {
-      std::vector<Atom> conversion_results;
+      std::vector<XAtom> conversion_results;
       for (size_t i = 0; i < conversions.size(); ++i) {
         bool conversion_successful = ProcessTarget(conversions[i].first,
-                                                   event.requestor,
+                                                   requestor,
                                                    conversions[i].second);
         conversion_results.push_back(conversions[i].first);
         conversion_results.push_back(
@@ -143,38 +147,38 @@ void SelectionOwner::OnSelectionRequest(const XSelectionRequestEvent& event) {
       // what GTK does.
       XChangeProperty(
           x_display_,
-          event.requestor,
-          event.property,
+          requestor,
+          requested_property,
           atom_cache_.GetAtom(kAtomPair),
           32,
           PropModeReplace,
           reinterpret_cast<const unsigned char*>(&conversion_results.front()),
           conversion_results.size());
 
-      reply.xselection.property = event.property;
+      reply.xselection.property = requested_property;
     }
   } else {
-    if (ProcessTarget(event.target, event.requestor, event.property))
-      reply.xselection.property = event.property;
+    if (ProcessTarget(requested_target, requestor, requested_property))
+      reply.xselection.property = requested_property;
   }
 
   // Send off the reply.
-  XSendEvent(x_display_, event.requestor, False, 0, &reply);
+  XSendEvent(x_display_, requestor, False, 0, &reply);
 }
 
-void SelectionOwner::OnSelectionClear(const XSelectionClearEvent& event) {
+void SelectionOwner::OnSelectionClear(const XEvent& event) {
   DLOG(ERROR) << "SelectionClear";
 
   // TODO(erg): If we receive a SelectionClear event while we're handling data,
   // we need to delay clearing.
 }
 
-bool SelectionOwner::ProcessTarget(Atom target,
-                                   ::Window requestor,
-                                   ::Atom property) {
-  Atom multiple_atom = atom_cache_.GetAtom(kMultiple);
-  Atom save_targets_atom = atom_cache_.GetAtom(kSaveTargets);
-  Atom targets_atom = atom_cache_.GetAtom(kTargets);
+bool SelectionOwner::ProcessTarget(XAtom target,
+                                   XID requestor,
+                                   XAtom property) {
+  XAtom multiple_atom = atom_cache_.GetAtom(kMultiple);
+  XAtom save_targets_atom = atom_cache_.GetAtom(kSaveTargets);
+  XAtom targets_atom = atom_cache_.GetAtom(kTargets);
 
   if (target == multiple_atom || target == save_targets_atom)
     return false;
@@ -182,7 +186,7 @@ bool SelectionOwner::ProcessTarget(Atom target,
   if (target == targets_atom) {
     // We have been asked for TARGETS. Send an atom array back with the data
     // types we support.
-    std::vector<Atom> targets;
+    std::vector<XAtom> targets;
     targets.push_back(targets_atom);
     targets.push_back(save_targets_atom);
     targets.push_back(multiple_atom);
@@ -212,4 +216,3 @@ bool SelectionOwner::ProcessTarget(Atom target,
 }
 
 }  // namespace ui
-

ui/base/x/selection_owner.h

@@ -5,11 +5,6 @@
 #ifndef UI_BASE_X_SELECTION_OWNER_H_
 #define UI_BASE_X_SELECTION_OWNER_H_
 
-#include <X11/Xlib.h>
-
-// Get rid of a macro from Xlib.h that conflicts with Aura's RootWindow class.
-#undef RootWindow
-
 #include <vector>
 
 #include "base/basictypes.h"
@@ -17,6 +12,7 @@
 #include "ui/base/ui_base_export.h"
 #include "ui/base/x/selection_utils.h"
 #include "ui/gfx/x/x11_atom_cache.h"
+#include "ui/gfx/x/x11_types.h"
 
 namespace ui {
 
@@ -27,16 +23,16 @@ namespace ui {
 // processes.
 class UI_BASE_EXPORT SelectionOwner {
  public:
-  SelectionOwner(Display* xdisplay,
-                 ::Window xwindow,
-                 ::Atom selection_name);
+  SelectionOwner(XDisplay* xdisplay,
+                 XID xwindow,
+                 XAtom selection_name);
   ~SelectionOwner();
 
   // Returns the current selection data. Useful for fast paths.
   const SelectionFormatMap& selection_format_map() { return format_map_; }
 
   // Appends a list of types we're offering to |targets|.
-  void RetrieveTargets(std::vector<Atom>* targets);
+  void RetrieveTargets(std::vector<XAtom>* targets);
 
   // Attempts to take ownership of the selection. If we're successful, present
   // |data| to other windows.
@@ -47,8 +43,8 @@ class UI_BASE_EXPORT SelectionOwner {
   void ClearSelectionOwner();
 
   // It is our owner's responsibility to plumb X11 events on |xwindow_| to us.
-  void OnSelectionRequest(const XSelectionRequestEvent& event);
-  void OnSelectionClear(const XSelectionClearEvent& event);
+  void OnSelectionRequest(const XEvent& event);
+  void OnSelectionClear(const XEvent& event);
   // TODO(erg): Do we also need to follow PropertyNotify events? We currently
   // don't, but there were open todos in the previous implementation.
 
@@ -56,14 +52,14 @@ class UI_BASE_EXPORT SelectionOwner {
   // Attempts to convert the selection to |target|. If the conversion is
   // successful, true is returned and the result is stored in the |property|
   // of |requestor|.
-  bool ProcessTarget(::Atom target, ::Window requestor, ::Atom property);
+  bool ProcessTarget(XAtom target, XID requestor, XAtom property);
 
   // Our X11 state.
-  Display* x_display_;
-  ::Window x_window_;
+  XDisplay* x_display_;
+  XID x_window_;
 
   // The X11 selection that this instance communicates on.
-  ::Atom selection_name_;
+  XAtom selection_name_;
 
   // The data we are currently serving.
   SelectionFormatMap format_map_;