linux_aura: Redo how memory is handled in clipboard/drag code.

ui/base/x/x11_util.cc

 // Copyright (c) 2012 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.
 
 // This file defines utility functions for X11 (Linux only). This code has been
 // ported from XCB since we can't use XCB on Ubuntu while its 32-bit support
 // remains woefully incomplete.
 
 #include "ui/base/x/x11_util.h"
 
@@ skipping 745 matching lines @@
                            &type, &format, &num_items, &property);
   if (result != Success)
     return false;
 
   XFree(property);
   return num_items > 0;
 }
 
 bool GetRawBytesOfProperty(XID window,
                            Atom property,
-                           unsigned char** out_data,
+                           scoped_refptr<base::RefCountedMemory>* out_data,
                            size_t* out_data_bytes,
                            size_t* out_data_items,
                            Atom* out_type) {
   // 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(GetXDisplay(), window, property,
                          0, 0x1FFFFFFF /* MAXINT32 / 4 */, False,
                          AnyPropertyType, &prop_type, &prop_format,
                          &nitems, &nbytes, &property_data) != Success) {
     return false;
   }
 
   if (prop_type == None)
     return false;
 
+  size_t bytes = 0;
+  // 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:
+      bytes = nitems;
+      break;
+    case 16:
+      bytes = sizeof(short) * nitems;
+      break;
+    case 32:
+      bytes = sizeof(long) * nitems;
+      break;
+    default:
+      NOTREACHED();
+      break;
+  }
+
+  if (out_data_bytes)
+    *out_data_bytes = bytes;
+
   if (out_data)
-    *out_data = property_data;
+    *out_data = new XRefcountedMemory(property_data, bytes);
   else
     XFree(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;
 }
 
 bool GetIntProperty(XID window, const std::string& property_name, int* value) {
@@ skipping 673 matching lines @@
   key_event.y = 0;
   key_event.x_root = 0;
   key_event.y_root = 0;
   key_event.state = XKeyEventState(flags);
   key_event.keycode = XKeyEventKeyCode(key_code, flags, display);
   key_event.same_screen = 1;
   event->type = key_event.type;
   event->xkey = key_event;
 }
 
+const unsigned char* XRefcountedMemory::front() const {
+  return x11_data_;
+}
+
+size_t XRefcountedMemory::size() const {
+  return length_;
+}
+
+XRefcountedMemory::~XRefcountedMemory() {
+  XFree(x11_data_);
+}
+
 XScopedString::~XScopedString() {
   XFree(string_);
 }
 
 XScopedImage::~XScopedImage() {
   reset(NULL);
 }
 
 void XScopedImage::reset(XImage* image) {
   if (image_ == image)
@@ skipping 145 matching lines @@
       << "request_code " << static_cast<int>(error_event.request_code) << ", "
       << "minor_code " << static_cast<int>(error_event.minor_code)
       << " (" << request_str << ")";
 }
 
 // ----------------------------------------------------------------------------
 // End of x11_util_internal.h
 
 
 }  // namespace ui