Process SelectionRequestor::PerformBlockingConvertSelection() requests one at a time

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 223 matching lines @@
   X11AtomCache* atom_cache() { return &atom_cache_; }
 
   // Returns the X11 type that we pass to various XSelection functions for the
   // given type.
   ::Atom LookupSelectionForClipboardType(ClipboardType type) const;
 
   // Returns the X11 type that we pass to various XSelection functions for
   // CLIPBOARD_TYPE_COPY_PASTE.
   ::Atom GetCopyPasteSelection() const;
 
-  // Returns the object which is responsible for communication on |type|.
-  SelectionRequestor* GetSelectionRequestorForClipboardType(ClipboardType type);
-
   // Finds the SelectionFormatMap for the incoming selection 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_.
@@ skipping 41 matching lines @@
 
   // Our X11 state.
   Display* x_display_;
   ::Window x_root_window_;
 
   // 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_;
-  SelectionRequestor clipboard_manager_requestor_;
+  // Object which requests and receives selection data.
+  SelectionRequestor selection_requestor_;
 
   // Temporary target map that we write to during DispatchObects.
   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_(gfx::GetXDisplay()),
       x_root_window_(DefaultRootWindow(x_display_)),
       x_window_(XCreateWindow(
           x_display_, x_root_window_,
           -100, -100, 10, 10,  // x, y, width, height
           0,                   // border width
           CopyFromParent,      // depth
           InputOnly,
           CopyFromParent,      // visual
           0,
           NULL)),
       atom_cache_(x_display_, kAtomsToCache),
-      clipboard_requestor_(x_display_, x_window_,
-                           atom_cache_.GetAtom(kClipboard), this),
-      primary_requestor_(x_display_, x_window_, XA_PRIMARY, this),
-      clipboard_manager_requestor_(x_display_, x_window_,
-                                   atom_cache_.GetAtom(kClipboardManager),
-                                   this),
+      selection_requestor_(x_display_, x_window_, this),
       clipboard_owner_(x_display_, x_window_, atom_cache_.GetAtom(kClipboard)),
       primary_owner_(x_display_, x_window_, XA_PRIMARY) {
   // We don't know all possible MIME types at compile time.
   atom_cache_.allow_uncached_atoms();
 
   XStoreName(x_display_, x_window_, "Chromium clipboard");
   XSelectInput(x_display_, x_window_, PropertyChangeMask);
 
   if (PlatformEventSource::GetInstance())
     PlatformEventSource::GetInstance()->AddPlatformEventDispatcher(this);
@@ skipping 20 matching lines @@
 
 const SelectionFormatMap& Clipboard::AuraX11Details::LookupStorageForAtom(
     ::Atom atom) {
   if (atom == XA_PRIMARY)
     return primary_owner_.selection_format_map();
 
   DCHECK_EQ(GetCopyPasteSelection(), atom);
   return clipboard_owner_.selection_format_map();
 }
 
-ui::SelectionRequestor*
-Clipboard::AuraX11Details::GetSelectionRequestorForClipboardType(
-    ClipboardType type) {
-  if (type == CLIPBOARD_TYPE_COPY_PASTE)
-    return &clipboard_requestor_;
-  else
-    return &primary_requestor_;
-}
-
 void Clipboard::AuraX11Details::CreateNewClipboardData() {
   clipboard_data_ = SelectionFormatMap();
 }
 
 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, memory);
 }
@@ skipping 15 matching lines @@
     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())
         return SelectionData(format_map_it->first, format_map_it->second);
     }
   } else {
     TargetList targets = WaitAndGetTargetsList(type);
-    SelectionRequestor* receiver = GetSelectionRequestorForClipboardType(type);
 
+    ::Atom selection_name = LookupSelectionForClipboardType(type);

[Daniel Erat, 2014/07/16 22:17:00]

doesn't need to happen in this change, but these can all be changed to XAtom
now, right?

[pkotwicz, 2014/07/17 19:38:34]

Acknowledged.

     std::vector< ::Atom> intersection;
     ui::GetAtomIntersection(types, targets.target_list(), &intersection);
-    return receiver->RequestAndWaitForTypes(intersection);
+    return selection_requestor_.RequestAndWaitForTypes(selection_name,
+                                                       intersection);
   }
 
   return SelectionData();
 }
 
 TargetList Clipboard::AuraX11Details::WaitAndGetTargetsList(
     ClipboardType type) {
   ::Atom selection_name = LookupSelectionForClipboardType(type);
   std::vector< ::Atom> out;
   if (XGetSelectionOwner(x_display_, selection_name) == x_window_) {
     // We can local fastpath and return the list of local targets.
     const SelectionFormatMap& format_map = LookupStorageForAtom(selection_name);
 
     for (SelectionFormatMap::const_iterator it = format_map.begin();
          it != format_map.end(); ++it) {
       out.push_back(it->first);
     }
   } else {
     scoped_refptr<base::RefCountedMemory> data;
     size_t out_data_items = 0;
     ::Atom out_type = None;
 
-    SelectionRequestor* receiver = GetSelectionRequestorForClipboardType(type);
-    if (receiver->PerformBlockingConvertSelection(atom_cache_.GetAtom(kTargets),
-                                                  &data,
-                                                  &out_data_items,
-                                                  &out_type)) {
+    if (selection_requestor_.PerformBlockingConvertSelection(
+            selection_name,
+            atom_cache_.GetAtom(kTargets),
+            &data,
+            &out_data_items,
+            &out_type)) {
       // Some apps return an |out_type| of "TARGETS". (crbug.com/377893)
       if (out_type == XA_ATOM || out_type == atom_cache_.GetAtom(kTargets)) {
         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]);
       }
     } 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) {
         ::Atom type = None;
-        if (receiver->PerformBlockingConvertSelection(*it,
-                                                      NULL,
-                                                      NULL,
-                                                      &type) &&
+        if (selection_requestor_.PerformBlockingConvertSelection(selection_name,
+                                                                 *it,
+                                                                 NULL,
+                                                                 NULL,
+                                                                 &type) &&
             type == *it) {
           out.push_back(*it);
         }
       }
     }
   }
 
   return TargetList(out, &atom_cache_);
 }
 
@@ skipping 23 matching lines @@
   ::Atom clipboard_manager_atom = atom_cache_.GetAtom(kClipboardManager);
   if (XGetSelectionOwner(x_display_, clipboard_manager_atom) == None)
     return;
 
   const SelectionFormatMap& format_map = LookupStorageForAtom(selection);
   if (format_map.size() == 0)
     return;
   std::vector<Atom> targets = format_map.GetTypes();
 
   base::TimeTicks start = base::TimeTicks::Now();
-  clipboard_manager_requestor_.PerformBlockingConvertSelectionWithParameter(
-      atom_cache_.GetAtom(kSaveTargets), targets);
+  selection_requestor_.PerformBlockingConvertSelectionWithParameter(
+      atom_cache_.GetAtom(kClipboardManager),
+      atom_cache_.GetAtom(kSaveTargets),
+      targets);
   UMA_HISTOGRAM_TIMES("Clipboard.X11StoreCopyPasteDuration",
                       base::TimeTicks::Now() - start);
 }
 
 bool Clipboard::AuraX11Details::CanDispatchEvent(const PlatformEvent& event) {
   return event->xany.window == x_window_;
 }
 
 uint32_t Clipboard::AuraX11Details::DispatchEvent(const PlatformEvent& xev) {
   switch (xev->type) {
     case SelectionRequest: {
       if (xev->xselectionrequest.selection == XA_PRIMARY) {
         primary_owner_.OnSelectionRequest(xev->xselectionrequest);
       } 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);
       }
       break;
     }
-    case SelectionNotify: {
-      ::Atom selection = xev->xselection.selection;
-      if (selection == XA_PRIMARY)
-        primary_requestor_.OnSelectionNotify(*xev);
-      else if (selection == GetCopyPasteSelection())
-        clipboard_requestor_.OnSelectionNotify(*xev);
-      else if (selection == atom_cache_.GetAtom(kClipboardManager))
-        clipboard_manager_requestor_.OnSelectionNotify(*xev);
+    case SelectionNotify:
+      selection_requestor_.OnSelectionNotify(*xev);
       break;
-    }
     case SelectionClear: {
       if (xev->xselectionclear.selection == XA_PRIMARY) {
         primary_owner_.OnSelectionClear(xev->xselectionclear);
       } 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);
         }
       break;
@@ skipping 348 matching lines @@
   return type;
 }
 
 // static
 const Clipboard::FormatType& Clipboard::GetPepperCustomDataFormatType() {
   CR_DEFINE_STATIC_LOCAL(FormatType, type, (kMimeTypePepperCustomData));
   return type;
 }
 
 }  // namespace ui