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

ui/views/widget/desktop_aura/desktop_drag_drop_client_aurax11.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.
 
 #include "ui/views/widget/desktop_aura/desktop_drag_drop_client_aurax11.h"
 
 #include <X11/Xatom.h>
 
 #include "base/event_types.h"
 #include "base/message_loop.h"
@@ skipping 141 matching lines @@
 
   // Called to request the next target from the source window. This is only
   // done on the first XdndPosition; after that, we cache the data offered by
   // the source window.
   void RequestNextTarget();
 
   // Called when XSelection data has been copied to our process.
   void OnSelectionNotify(const XSelectionEvent& xselection);
 
   // Clones the fetched targets.
-  scoped_ptr<ui::SelectionFormatMap> CloneFetchedTargets() {
-    DCHECK(fetched_targets_);
-    return fetched_targets_->Clone();
-  }
+  const ui::SelectionFormatMap& fetched_targets() { return fetched_targets_; }
 
   // Reads the "XdndActionList" property from |source_window| and copies it
   // into |actions|.
   void ReadActions();
 
   // Creates a ui::DragDropTypes::DragOperation representation of the current
   // action list.
   int GetDragOperation() const;
 
  private:
@@ skipping 13 matching lines @@
   DesktopDragDropClientAuraX11* drag_drop_client_;
 
   // Whether we're blocking the handling of an XdndPosition message by waiting
   // for |unfetched_targets_| to be fetched.
   bool waiting_to_handle_position_;
 
   // Where the cursor is on screen.
   gfx::Point screen_point_;
 
   // A SelectionFormatMap of data that we have in our process.
-  scoped_ptr<ui::SelectionFormatMap> fetched_targets_;
+  ui::SelectionFormatMap fetched_targets_;
 
   // The names of various data types offered by the other window that we
   // haven't fetched and put in |fetched_targets_| yet.
   std::vector<Atom> unfetched_targets_;
 
   // Possible actions.
   std::vector<Atom> actions_;
 
   DISALLOW_COPY_AND_ASSIGN(X11DragContext);
 };
@@ skipping 34 matching lines @@
     XSelectInput(base::MessagePumpAuraX11::GetDefaultXDisplay(),
                  source_window_, PropertyChangeMask);
 
     // We must perform a full sync here because we could be racing
     // |source_window_|.
     XSync(base::MessagePumpAuraX11::GetDefaultXDisplay(), False);
   } else {
     // This drag originates from an aura window within our process. This means
     // that we can shortcut the X11 server and ask the owning SelectionOwner
     // for the data it's offering.
-    fetched_targets_ = client->CloneFormatMap();
+    fetched_targets_ = client->GetFormatMap();
     unfetched_targets_.clear();
   }
 
   ReadActions();
 }
 
 DesktopDragDropClientAuraX11::X11DragContext::~X11DragContext() {
   DesktopDragDropClientAuraX11* client =
       DesktopDragDropClientAuraX11::GetForWindow(source_window_);
   if (!client) {
     // Unsubscribe from message events.
     base::MessagePumpAuraX11::Current()->RemoveDispatcherForWindow(
         source_window_);
   }
 }
 
 void DesktopDragDropClientAuraX11::X11DragContext::OnStartXdndPositionMessage(
     DesktopDragDropClientAuraX11* client,
     ::Window source_window,
     const gfx::Point& screen_point) {
   DCHECK_EQ(source_window_, source_window);
 
   if (!unfetched_targets_.empty()) {
     // We have unfetched targets. That means we need to pause the handling of
     // the position message and ask the other window for its data.
     screen_point_ = screen_point;
     drag_drop_client_ = client;
     waiting_to_handle_position_ = true;
 
-    fetched_targets_.reset(new ui::SelectionFormatMap);
+    fetched_targets_ = ui::SelectionFormatMap();
     RequestNextTarget();
   } else {
     client->CompleteXdndPosition(source_window, screen_point);
   }
 }
 
 void DesktopDragDropClientAuraX11::X11DragContext::RequestNextTarget() {
   ::Atom target = unfetched_targets_.back();
   unfetched_targets_.pop_back();
 
   XConvertSelection(base::MessagePumpAuraX11::GetDefaultXDisplay(),
                     atom_cache_->GetAtom(kXdndSelection),
                     target,
                     atom_cache_->GetAtom(kChromiumDragReciever),
                     local_window_,
                     CurrentTime);
 }
 
 void DesktopDragDropClientAuraX11::X11DragContext::OnSelectionNotify(
     const XSelectionEvent& event) {
   DCHECK(waiting_to_handle_position_);
   DCHECK(drag_drop_client_);
   DCHECK_EQ(event.property, atom_cache_->GetAtom(kChromiumDragReciever));
 
-  unsigned char* data = NULL;
-  size_t data_bytes = 0;
+  scoped_refptr<base::RefCountedMemory> data;
   ::Atom type = None;
   if (ui::GetRawBytesOfProperty(local_window_, event.property,
-                                &data, &data_bytes, NULL, &type)) {
-    char* copied_data = new char[data_bytes];
-    memcpy(copied_data, data, data_bytes);
-    fetched_targets_->Insert(event.target, copied_data, data_bytes);
-    XFree(data);
+                                &data, NULL, NULL, &type)) {
+    fetched_targets_.Insert(event.target, data);
   }
 
   if (!unfetched_targets_.empty()) {
     RequestNextTarget();
   } else {
     waiting_to_handle_position_ = false;
     drag_drop_client_->CompleteXdndPosition(source_window_, screen_point_);
     drag_drop_client_ = NULL;
   }
 }
@@ skipping 182 matching lines @@
   DVLOG(1) << "XdndDrop";
 
   unsigned long source_window = event.data.l[0];
 
   int drag_operation = ui::DragDropTypes::DRAG_NONE;
   if (target_window_) {
     aura::client::DragDropDelegate* delegate =
         aura::client::GetDragDropDelegate(target_window_);
     if (delegate) {
       ui::OSExchangeData data(new ui::OSExchangeDataProviderAuraX11(
-          xwindow_, target_current_context_->CloneFetchedTargets()));
+          xwindow_, target_current_context_->fetched_targets()));
 
       ui::DropTargetEvent event(data,
                                 target_window_location_,
                                 target_window_root_location_,
                                 target_current_context_->GetDragOperation());
       drag_operation = delegate->OnPerformDrop(event);
     }
 
     target_window_->RemoveObserver(this);
     target_window_ = NULL;
@@ skipping 155 matching lines @@
     target_window_changed = true;
   }
   *delegate = NULL;
   if (!target_window_)
     return;
   *delegate = aura::client::GetDragDropDelegate(target_window_);
   if (!*delegate)
     return;
 
   data->reset(new OSExchangeData(new ui::OSExchangeDataProviderAuraX11(
-      xwindow_, target_current_context_->CloneFetchedTargets())));
+      xwindow_, target_current_context_->fetched_targets())));
   gfx::Point location = root_location;
   aura::Window::ConvertPointToTarget(root_window_, target_window_, &location);
 
   target_window_location_ = location;
   target_window_root_location_ = root_location;
 
   event->reset(new ui::DropTargetEvent(
       *(data->get()),
       location,
       root_location,
@@ skipping 40 matching lines @@
   std::vector< ::Atom> operations;
   if (drag_operation_ & ui::DragDropTypes::DRAG_COPY)
     operations.push_back(atom_cache_.GetAtom(kXdndActionCopy));
   if (drag_operation_ & ui::DragDropTypes::DRAG_MOVE)
     operations.push_back(atom_cache_.GetAtom(kXdndActionMove));
   if (drag_operation_ & ui::DragDropTypes::DRAG_LINK)
     operations.push_back(atom_cache_.GetAtom(kXdndActionLink));
   return operations;
 }
 
-scoped_ptr<ui::SelectionFormatMap>
-DesktopDragDropClientAuraX11::CloneFormatMap() const {
-  return source_provider_ ? source_provider_->CloneFormatMap() :
-      scoped_ptr<ui::SelectionFormatMap>();
+ui::SelectionFormatMap DesktopDragDropClientAuraX11::GetFormatMap() const {
+  return source_provider_ ? source_provider_->GetFormatMap() :
+      ui::SelectionFormatMap();
 }
 
 void DesktopDragDropClientAuraX11::CompleteXdndPosition(
     ::Window source_window,
     const gfx::Point& screen_point) {
   int drag_operation = ui::DragDropTypes::DRAG_NONE;
   scoped_ptr<ui::OSExchangeData> data;
   scoped_ptr<ui::DropTargetEvent> drop_target_event;
   DragDropDelegate* delegate = NULL;
   DragTranslate(screen_point, &data, &drop_target_event, &delegate);
@@ skipping 136 matching lines @@
   // GdkEvent about the failed drag. (And sending this message doesn't appear
   // to go through normal xlib machinery, but instead passes through the low
   // level xProto (the x11 wire format) that I don't understand.
   //
   // I'm unsure if I have to jump through those hoops, or if XSendEvent is
   // sufficient.
   XSendEvent(xdisplay_, xid, False, 0, xev);
 }
 
 }  // namespace views