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

ui/base/clipboard/clipboard_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/base/clipboard/clipboard.h"
 
 #include <X11/extensions/Xfixes.h>
 #include <X11/Xatom.h>
 #include <list>
 #include <set>
@@ skipping 221 matching lines @@
   X11AtomCache* atom_cache() { return &atom_cache_; }
 
   // Returns the X11 type that we pass to various XSelection functions for the
   // given buffer.
   ::Atom LookupSelectionForBuffer(Buffer buffer) const;
 
   // Returns the object which is responsible for communication on |buffer|.
   SelectionRequestor* GetSelectionRequestorForBuffer(Buffer buffer);
 
   // Finds the SelectionFormatMap for the incoming selection atom.
-  SelectionFormatMap* LookupStorageForAtom(::Atom atom);
+  const SelectionFormatMap& LookupStorageForAtom(::Atom atom);
 
   // As we need to collect all the data types before we tell X11 that we own a
   // particular selection, we create a temporary clipboard mapping that
   // InsertMapping writes to. Then we commit it in TakeOwnershipOfSelection,
   // where we save it in one of the clipboard data slots.
   void CreateNewClipboardData();
 
   // Inserts a mapping into clipboard_data_.
-  void InsertMapping(const std::string& key, char* data, size_t data_len);
+  void InsertMapping(const std::string& key,
+                     const scoped_refptr<base::RefCountedMemory>& memory);
 
   // Moves the temporary |clipboard_data_| to the long term data storage for
   // |buffer|.
   void TakeOwnershipOfSelection(Buffer buffer);
 
   // Returns the first of |types| offered by the current selection holder in
   // |data_out|, or returns NULL if none of those types are available.
   //
   // If the selection holder is us, this call is synchronous and we pull
   // the data out of |clipboard_selection_| or |primary_selection_|. If the
   // selection holder is some other window, we spin up a nested message loop
   // and do the asynchronous dance with whatever application is holding the
   // selection.
-  scoped_ptr<SelectionData> RequestAndWaitForTypes(
-      Buffer buffer,
-      const std::vector< ::Atom>& types);
+  ui::SelectionData RequestAndWaitForTypes(Buffer buffer,
+                                           const std::vector< ::Atom>& types);
 
   // Retrieves the list of possible data types the current clipboard owner has.
   //
   // If the selection holder is us, this is synchronous, otherwise this runs a
   // blocking message loop.
   TargetList WaitAndGetTargetsList(Buffer buffer);
 
   // Returns a list of all text atoms that we handle.
   std::vector< ::Atom> GetTextAtoms() const;
 
@@ skipping 14 matching lines @@
   // Input-only window used as a selection owner.
   ::Window x_window_;
 
   X11AtomCache atom_cache_;
 
   // Objects which request and receive selection data.
   SelectionRequestor clipboard_requestor_;
   SelectionRequestor primary_requestor_;
 
   // Temporary target map that we write to during DispatchObects.
-  scoped_ptr<SelectionFormatMap> clipboard_data_;
+  SelectionFormatMap clipboard_data_;
 
   // Objects which offer selection data to other windows.
   SelectionOwner clipboard_owner_;
   SelectionOwner primary_owner_;
 
   DISALLOW_COPY_AND_ASSIGN(AuraX11Details);
 };
 
 Clipboard::AuraX11Details::AuraX11Details()
     : x_display_(GetXDisplay()),
@@ skipping 25 matching lines @@
 Clipboard::AuraX11Details::~AuraX11Details() {
   base::MessagePumpAuraX11::Current()->RemoveDispatcherForWindow(x_window_);
 
   XDestroyWindow(x_display_, x_window_);
 }
 
 ::Atom Clipboard::AuraX11Details::LookupSelectionForBuffer(
     Buffer buffer) const {
   if (buffer == BUFFER_STANDARD)
     return atom_cache_.GetAtom(kClipboard);
-  else
-    return XA_PRIMARY;
+
+  return XA_PRIMARY;
 }
 
-SelectionFormatMap* Clipboard::AuraX11Details::LookupStorageForAtom(
+const SelectionFormatMap& Clipboard::AuraX11Details::LookupStorageForAtom(
     ::Atom atom) {
   if (atom == XA_PRIMARY)
     return primary_owner_.selection_format_map();
-  else if (atom == atom_cache_.GetAtom(kClipboard))
-    return clipboard_owner_.selection_format_map();
-  else
-    return NULL;
+
+  DCHECK_EQ(atom_cache_.GetAtom(kClipboard), atom);
+  return clipboard_owner_.selection_format_map();
 }
 
 ui::SelectionRequestor*
 Clipboard::AuraX11Details::GetSelectionRequestorForBuffer(Buffer buffer) {
   if (buffer == BUFFER_STANDARD)
     return &clipboard_requestor_;
   else
     return &primary_requestor_;
 }
 
 void Clipboard::AuraX11Details::CreateNewClipboardData() {
-  clipboard_data_.reset(new SelectionFormatMap);
+  clipboard_data_ = SelectionFormatMap();
 }
 
-void Clipboard::AuraX11Details::InsertMapping(const std::string& key,
-                                              char* data,
-                                              size_t data_len) {
+void Clipboard::AuraX11Details::InsertMapping(
+    const std::string& key,
+    const scoped_refptr<base::RefCountedMemory>& memory) {
   ::Atom atom_key = atom_cache_.GetAtom(key.c_str());
-  clipboard_data_->Insert(atom_key, data, data_len);
+  clipboard_data_.Insert(atom_key, memory);
 }
 
 void Clipboard::AuraX11Details::TakeOwnershipOfSelection(Buffer buffer) {
   if (buffer == BUFFER_STANDARD)
-    return clipboard_owner_.TakeOwnershipOfSelection(clipboard_data_.Pass());
+    return clipboard_owner_.TakeOwnershipOfSelection(clipboard_data_);
   else
-    return primary_owner_.TakeOwnershipOfSelection(clipboard_data_.Pass());
+    return primary_owner_.TakeOwnershipOfSelection(clipboard_data_);
 }
 
-scoped_ptr<SelectionData> Clipboard::AuraX11Details::RequestAndWaitForTypes(
+SelectionData Clipboard::AuraX11Details::RequestAndWaitForTypes(
     Buffer buffer,
     const std::vector< ::Atom>& types) {
   ::Atom selection_name = LookupSelectionForBuffer(buffer);
   if (XGetSelectionOwner(x_display_, selection_name) == x_window_) {
     // We can local fastpath instead of playing the nested message loop game
     // with the X server.
-    SelectionFormatMap* format_map = LookupStorageForAtom(selection_name);
-    DCHECK(format_map);
+    const SelectionFormatMap& format_map = LookupStorageForAtom(selection_name);
 
     for (std::vector< ::Atom>::const_iterator it = types.begin();
          it != types.end(); ++it) {
-      SelectionFormatMap::const_iterator format_map_it = format_map->find(*it);
-      if (format_map_it != format_map->end()) {
-        scoped_ptr<SelectionData> data_out(new SelectionData);
-        data_out->Set(format_map_it->first, format_map_it->second.first,
-                      format_map_it->second.second, false);
-        return data_out.Pass();
-      }
+      SelectionFormatMap::const_iterator format_map_it = format_map.find(*it);
+      if (format_map_it != format_map.end())
+        return SelectionData(format_map_it->first, format_map_it->second);
     }
   } else {
     TargetList targets = WaitAndGetTargetsList(buffer);
     SelectionRequestor* receiver = GetSelectionRequestorForBuffer(buffer);
 
     std::vector< ::Atom> intersection;
     ui::GetAtomIntersection(targets.target_list(), types, &intersection);
     return receiver->RequestAndWaitForTypes(intersection);
   }
 
-  return scoped_ptr<SelectionData>();
+  return SelectionData();
 }
 
 TargetList Clipboard::AuraX11Details::WaitAndGetTargetsList(
     Buffer buffer) {
   ::Atom selection_name = LookupSelectionForBuffer(buffer);
   std::vector< ::Atom> out;
   if (XGetSelectionOwner(x_display_, selection_name) == x_window_) {
     // We can local fastpath and return the list of local targets.
-    SelectionFormatMap* format_map = LookupStorageForAtom(selection_name);
-    DCHECK(format_map);
+    const SelectionFormatMap& format_map = LookupStorageForAtom(selection_name);
 
-    for (SelectionFormatMap::const_iterator it = format_map->begin();
-         it != format_map->end(); ++it) {
+    for (SelectionFormatMap::const_iterator it = format_map.begin();
+         it != format_map.end(); ++it) {
       out.push_back(it->first);
     }
   } else {
-    unsigned char* data = NULL;
+    scoped_refptr<base::RefCountedMemory> data;
     size_t out_data_items = 0;
     ::Atom out_type = None;
 
     SelectionRequestor* receiver = GetSelectionRequestorForBuffer(buffer);
     if (receiver->PerformBlockingConvertSelection(atom_cache_.GetAtom(kTargets),
                                                   &data,
                                                   NULL,
                                                   &out_data_items,
                                                   &out_type)) {
-      ::Atom* atom_array = reinterpret_cast< ::Atom*>(data);
+      const ::Atom* atom_array = reinterpret_cast<const ::Atom*>(data->front());
       for (size_t i = 0; i < out_data_items; ++i)
         out.push_back(atom_array[i]);
-
-      XFree(data);
     } else {
       // There was no target list. Most Java apps doesn't offer a TARGETS list,
       // even though they AWT to. They will offer individual text types if you
       // ask. If this is the case we attempt to make sense of the contents as
       // text. This is pretty unfortunate since it means we have to actually
       // copy the data to see if it is available, but at least this path
       // shouldn't be hit for conforming programs.
       std::vector< ::Atom> types = GetTextAtoms();
       for (std::vector< ::Atom>::const_iterator it = types.begin();
            it != types.end(); ++it) {
@@ skipping 133 matching lines @@
   if (target_list.ContainsText())
     types->push_back(UTF8ToUTF16(kMimeTypeText));
   if (target_list.ContainsFormat(GetHtmlFormatType()))
     types->push_back(UTF8ToUTF16(kMimeTypeHTML));
   if (target_list.ContainsFormat(GetRtfFormatType()))
     types->push_back(UTF8ToUTF16(kMimeTypeRTF));
   if (target_list.ContainsFormat(GetBitmapFormatType()))
     types->push_back(UTF8ToUTF16(kMimeTypePNG));
   *contains_filenames = false;
 
-  scoped_ptr<SelectionData> data(aurax11_details_->RequestAndWaitForTypes(
+  SelectionData data(aurax11_details_->RequestAndWaitForTypes(
       buffer,
       aurax11_details_->GetAtomsForFormat(GetWebCustomDataFormatType())));
-  if (!data.get())
-    return;
-
-  ReadCustomDataTypes(data->data(), data->size(), types);
+  if (data.IsValid())
+    ReadCustomDataTypes(data.GetData(), data.GetSize(), types);
 }
 
 void Clipboard::ReadText(Buffer buffer, string16* result) const {
   DCHECK(CalledOnValidThread());
 
-  scoped_ptr<SelectionData> data(aurax11_details_->RequestAndWaitForTypes(
+  SelectionData data(aurax11_details_->RequestAndWaitForTypes(
       buffer, aurax11_details_->GetTextAtoms()));
-  if (data.get()) {
-    std::string text = data->GetText();
+  if (data.IsValid()) {
+    std::string text = data.GetText();
     *result = UTF8ToUTF16(text);
   }
 }
 
 void Clipboard::ReadAsciiText(Buffer buffer, std::string* result) const {
   DCHECK(CalledOnValidThread());
 
-  scoped_ptr<SelectionData> data(aurax11_details_->RequestAndWaitForTypes(
+  SelectionData data(aurax11_details_->RequestAndWaitForTypes(
       buffer, aurax11_details_->GetTextAtoms()));
-  if (data.get())
-    result->assign(data->GetText());
+  if (data.IsValid())
+    result->assign(data.GetText());
 }
 
 // TODO(estade): handle different charsets.
 // TODO(port): set *src_url.
 void Clipboard::ReadHTML(Buffer buffer,
                          string16* markup,
                          std::string* src_url,
                          uint32* fragment_start,
                          uint32* fragment_end) const {
   DCHECK(CalledOnValidThread());
   markup->clear();
   if (src_url)
     src_url->clear();
   *fragment_start = 0;
   *fragment_end = 0;
 
-  scoped_ptr<SelectionData> data(aurax11_details_->RequestAndWaitForTypes(
+  SelectionData data(aurax11_details_->RequestAndWaitForTypes(
       buffer, aurax11_details_->GetAtomsForFormat(GetHtmlFormatType())));
-  if (!data.get())
-    return;
+  if (data.IsValid()) {
+    *markup = data.GetHtml();
 
-  *markup = data->GetHtml();
-
-  *fragment_start = 0;
-  DCHECK(markup->length() <= kuint32max);
-  *fragment_end = static_cast<uint32>(markup->length());
+    *fragment_start = 0;
+    DCHECK(markup->length() <= kuint32max);
+    *fragment_end = static_cast<uint32>(markup->length());
+  }
 }
 
 void Clipboard::ReadRTF(Buffer buffer, std::string* result) const {
   DCHECK(CalledOnValidThread());
 
-  scoped_ptr<SelectionData> data(aurax11_details_->RequestAndWaitForTypes(
+  SelectionData data(aurax11_details_->RequestAndWaitForTypes(
       buffer, aurax11_details_->GetAtomsForFormat(GetRtfFormatType())));
-  if (data.get())
-    data->AssignTo(result);
+  if (data.IsValid())
+    data.AssignTo(result);
 }
 
 SkBitmap Clipboard::ReadImage(Buffer buffer) const {
   DCHECK(CalledOnValidThread());
   NOTIMPLEMENTED();
   return SkBitmap();
 }
 
 void Clipboard::ReadCustomData(Buffer buffer,
                                const string16& type,
                                string16* result) const {
   DCHECK(CalledOnValidThread());
 
-  scoped_ptr<SelectionData> data(aurax11_details_->RequestAndWaitForTypes(
+  SelectionData data(aurax11_details_->RequestAndWaitForTypes(
       buffer,
       aurax11_details_->GetAtomsForFormat(GetWebCustomDataFormatType())));
-  if (!data.get())
-    return;
-
-  ReadCustomDataForType(data->data(), data->size(), type, result);
+  if (data.IsValid())
+    ReadCustomDataForType(data.GetData(), data.GetSize(), type, result);
 }
 
 void Clipboard::ReadBookmark(string16* title, std::string* url) const {
   DCHECK(CalledOnValidThread());
   // TODO(erg): This was left NOTIMPLEMENTED() in the gtk port too.
   NOTIMPLEMENTED();
 }
 
 void Clipboard::ReadData(const FormatType& format, std::string* result) const {
   DCHECK(CalledOnValidThread());
 
-  scoped_ptr<SelectionData> data(aurax11_details_->RequestAndWaitForTypes(
+  SelectionData data(aurax11_details_->RequestAndWaitForTypes(
       BUFFER_STANDARD, aurax11_details_->GetAtomsForFormat(format)));
-  if (data.get())
-    data->AssignTo(result);
+  if (data.IsValid())
+    data.AssignTo(result);
 }
 
 uint64 Clipboard::GetSequenceNumber(Buffer buffer) {
   DCHECK(CalledOnValidThread());
   if (buffer == BUFFER_STANDARD)
     return SelectionChangeObserver::GetInstance()->clipboard_sequence_number();
   else
     return SelectionChangeObserver::GetInstance()->primary_sequence_number();
 }
 
 void Clipboard::WriteText(const char* text_data, size_t text_len) {
-  char* data = new char[text_len];
-  memcpy(data, text_data, text_len);
+  std::string str(text_data, text_len);
+  scoped_refptr<base::RefCountedMemory> mem(
+      base::RefCountedString::TakeString(&str));
 
-  aurax11_details_->InsertMapping(kMimeTypeText, data, text_len);
-  aurax11_details_->InsertMapping(kText, data, text_len);
-  aurax11_details_->InsertMapping(kString, data, text_len);
-  aurax11_details_->InsertMapping(kUtf8String, data, text_len);
+  aurax11_details_->InsertMapping(kMimeTypeText, mem);
+  aurax11_details_->InsertMapping(kText, mem);
+  aurax11_details_->InsertMapping(kString, mem);
+  aurax11_details_->InsertMapping(kUtf8String, mem);
 }
 
 void Clipboard::WriteHTML(const char* markup_data,
                           size_t markup_len,
                           const char* url_data,
                           size_t url_len) {
   // TODO(estade): We need to expand relative links with |url_data|.
   static const char* html_prefix = "<meta http-equiv=\"content-type\" "
                                    "content=\"text/html; charset=utf-8\">";
-  size_t html_prefix_len = strlen(html_prefix);
-  size_t total_len = html_prefix_len + markup_len + 1;
+  std::string data = html_prefix;
+  data += std::string(markup_data, markup_len);
+  // Some programs expect NULL-terminated data. See http://crbug.com/42624
+  data += '\0';
 
-  char* data = new char[total_len];
-  snprintf(data, total_len, "%s", html_prefix);
-  memcpy(data + html_prefix_len, markup_data, markup_len);
-  // Some programs expect NULL-terminated data. See http://crbug.com/42624
-  data[total_len - 1] = '\0';
-
-  aurax11_details_->InsertMapping(kMimeTypeHTML, data, total_len);
+  scoped_refptr<base::RefCountedMemory> mem(
+      base::RefCountedString::TakeString(&data));
+  aurax11_details_->InsertMapping(kMimeTypeHTML, mem);
 }
 
 void Clipboard::WriteRTF(const char* rtf_data, size_t data_len) {
   WriteData(GetRtfFormatType(), rtf_data, data_len);
 }
 
 void Clipboard::WriteBookmark(const char* title_data,
                               size_t title_len,
                               const char* url_data,
                               size_t url_len) {
   // Write as a mozilla url (UTF16: URL, newline, title).
   string16 url = UTF8ToUTF16(std::string(url_data, url_len) + "\n");
   string16 title = UTF8ToUTF16(std::string(title_data, title_len));
-  int data_len = 2 * (title.length() + url.length());
 
-  char* data = new char[data_len];
-  memcpy(data, url.data(), 2 * url.length());
-  memcpy(data + 2 * url.length(), title.data(), 2 * title.length());
-  aurax11_details_->InsertMapping(kMimeTypeMozillaURL, data, data_len);
+  std::vector<unsigned char> data;
+  ui::AddString16ToVector(url, &data);
+  ui::AddString16ToVector(title, &data);
+  scoped_refptr<base::RefCountedMemory> mem(
+      base::RefCountedBytes::TakeVector(&data));
+
+  aurax11_details_->InsertMapping(kMimeTypeMozillaURL, mem);
 }
 
 // Write an extra flavor that signifies WebKit was the last to modify the
 // pasteboard. This flavor has no data.
 void Clipboard::WriteWebSmartPaste() {
-  aurax11_details_->InsertMapping(kMimeTypeWebkitSmartPaste, NULL, 0);
+  aurax11_details_->InsertMapping(kMimeTypeWebkitSmartPaste,
+                                  scoped_refptr<base::RefCountedMemory>());
 }
 
 void Clipboard::WriteBitmap(const char* pixel_data, const char* size_data) {
   // TODO(erg): I'm not sure if we should be writting BMP data here or
   // not. It's what the GTK port does, but I'm not sure it's the right thing to
   // do.
   NOTIMPLEMENTED();
 }
 
 void Clipboard::WriteData(const FormatType& format,
                           const char* data_data,
                           size_t data_len) {
   // We assume that certain mapping types are only written by trusted code.
   // Therefore we must upkeep their integrity.
   if (format.Equals(GetBitmapFormatType()))
     return;
-  char* data = new char[data_len];
-  memcpy(data, data_data, data_len);
-  aurax11_details_->InsertMapping(format.ToString(), data, data_len);
+
+  std::vector<unsigned char> bytes(data_data, data_data + data_len);
+  scoped_refptr<base::RefCountedMemory> mem(
+      base::RefCountedBytes::TakeVector(&bytes));
+  aurax11_details_->InsertMapping(format.ToString(), mem);
 }
 
 // static
 Clipboard::FormatType Clipboard::GetFormatType(
     const std::string& format_string) {
   return FormatType::Deserialize(format_string);
 }
 
 // static
 const Clipboard::FormatType& Clipboard::GetUrlFormatType() {
@@ skipping 58 matching lines @@
   return type;
 }
 
 // static
 const Clipboard::FormatType& Clipboard::GetPepperCustomDataFormatType() {
   CR_DEFINE_STATIC_LOCAL(FormatType, type, (kMimeTypePepperCustomData));
   return type;
 }
 
 }  // namespace ui