Drag on linux

ui/base/x/selection_requestor.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_requestor.h"
 
 #include "base/message_pump_aurax11.h"
 #include "base/run_loop.h"
 #include "ui/base/x/selection_utils.h"
+#include "ui/base/x/x11_util.h"
 
 namespace ui {
 
 namespace {
 
 const char kChromeSelection[] = "CHROME_SELECTION";
 
 const char* kAtomsToCache[] = {
   kChromeSelection,
   NULL
@@ skipping 40 matching lines @@
   current_target_ = target;
   in_nested_loop_ = true;
   quit_closure_ = run_loop.QuitClosure();
   run_loop.Run();
   in_nested_loop_ = false;
   current_target_ = None;
 
   if (returned_property_ != property_to_set)
     return false;
 
-  // Retrieve the data from our window.
-  unsigned long nitems = 0;
-  unsigned long nbytes = 0;
-  Atom prop_type = None;
-  int prop_format = 0;
-  unsigned char* property_data = NULL;
-  if (XGetWindowProperty(x_display_,
-                         x_window_,
-                         returned_property_,
-                         0, 0x1FFFFFFF /* MAXINT32 / 4 */, False,
-                         AnyPropertyType, &prop_type, &prop_format,
-                         &nitems, &nbytes, &property_data) != Success) {
-    return false;
-  }
-
-  if (prop_type == None)
-    return false;
-
-  if (out_data)
-    *out_data = property_data;
-
-  if (out_data_bytes) {
-    // So even though we should theoretically have nbytes (and we can't
-    // pass NULL there), we need to manually calculate the byte length here
-    // because nbytes always returns zero.
-    switch (prop_format) {
-      case 8:
-        *out_data_bytes = nitems;
-        break;
-      case 16:
-        *out_data_bytes = sizeof(short) * nitems;
-        break;
-      case 32:
-        *out_data_bytes = sizeof(long) * nitems;
-        break;
-      default:
-        NOTREACHED();
-        break;
-    }
-  }
-
-  if (out_data_items)
-    *out_data_items = nitems;
-
-  if (out_type)
-    *out_type = prop_type;
-
-  return true;
+  return ui::GetRawBytesOfProperty(x_window_, returned_property_,
+                                   out_data, out_data_bytes, out_data_items,
+                                   out_type);
 }
 
 scoped_ptr<SelectionData> SelectionRequestor::RequestAndWaitForTypes(
     const std::vector< ::Atom>& types) {
   for (std::vector< ::Atom>::const_iterator it = types.begin();
        it != types.end(); ++it) {
     unsigned char* data = NULL;
     size_t data_bytes = 0;
     ::Atom type = None;
     if (PerformBlockingConvertSelection(*it,
                                         &data,
                                         &data_bytes,
                                         NULL,
                                         &type) &&
         type == *it) {
-      scoped_ptr<SelectionData> data_out(new SelectionData(x_display_));
+      scoped_ptr<SelectionData> data_out(new SelectionData);
       data_out->Set(type, (char*)data, data_bytes, true);
       return data_out.Pass();
     }
   }
 
   return scoped_ptr<SelectionData>();
 }
 
 void SelectionRequestor::OnSelectionNotify(const XSelectionEvent& event) {
   if (!in_nested_loop_) {
     // This shouldn't happen; we're not waiting on the X server for data, but
     // any client can send any message...
     return;
   }
 
   if (selection_name_ == event.selection &&
       current_target_ == event.target) {
     returned_property_ = event.property;
   } else {
     // I am assuming that if some other client sent us a message after we've
     // asked for data, but it's malformed, we should just treat as if they sent
     // us an error message.
     returned_property_ = None;
   }
 
   quit_closure_.Run();
 }
 
 }  // namespace ui