[Desktop Linux]: Fix copy and pasting long selections

ui/base/x/selection_owner.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_owner.h"
 
 #include <algorithm>
 #include <X11/Xlib.h>
 #include <X11/Xatom.h>
 
 #include "base/logging.h"
+#include "base/memory/ptr_util.h"
 #include "ui/base/x/selection_utils.h"
 #include "ui/base/x/x11_util.h"
 #include "ui/base/x/x11_window_event_manager.h"
 #include "ui/events/platform/x11/x11_event_source.h"
 
 namespace ui {
 
 namespace {
 
 const char kAtomPair[] = "ATOM_PAIR";
@@ skipping 172 matching lines @@
   // TODO(erg): If we receive a SelectionClear event while we're handling data,
   // we need to delay clearing.
 }
 
 bool SelectionOwner::CanDispatchPropertyEvent(const XEvent& event) {
   return event.xproperty.state == PropertyDelete &&
          FindIncrementalTransferForEvent(event) != incremental_transfers_.end();
 }
 
 void SelectionOwner::OnPropertyEvent(const XEvent& event) {
-  std::vector<IncrementalTransfer>::iterator it =
-      FindIncrementalTransferForEvent(event);
+  IncrementalTransferIt it = FindIncrementalTransferForEvent(event);
   if (it == incremental_transfers_.end())
     return;
 
-  ProcessIncrementalTransfer(&(*it));
-  if (!it->data.get())
+  IncrementalTransfer* incremental_transfer = (*it).get();

[dcheng, 2017/02/17 07:42:13]

Does it->get() work?

[pkotwicz, 2017/02/17 19:19:07]

Yes it does :) Thank you!

+  ProcessIncrementalTransfer(incremental_transfer);
+  if (!incremental_transfer->data.get())
     CompleteIncrementalTransfer(it);
 }
 
 bool SelectionOwner::ProcessTarget(XAtom target,
                                    XID requestor,
                                    XAtom property) {
   XAtom multiple_atom = atom_cache_.GetAtom(kMultiple);
   XAtom save_targets_atom = atom_cache_.GetAtom(kSaveTargets);
   XAtom targets_atom = atom_cache_.GetAtom(kTargets);
   XAtom timestamp_atom = atom_cache_.GetAtom(kTimestamp);
@@ skipping 41 matching lines @@
                       PropModeReplace,
                       reinterpret_cast<unsigned char*>(&length),
                       1);
 
       // Wait for the selection requestor to indicate that it has processed
       // the selection result before sending the first chunk of data. The
       // selection requestor indicates this by deleting |property|.
       base::TimeTicks timeout =
           base::TimeTicks::Now() +
           base::TimeDelta::FromMilliseconds(kIncrementalTransferTimeoutMs);
-      requestor_events_.reset(
-          new ui::XScopedEventSelector(requestor, PropertyChangeMask));
-      incremental_transfers_.push_back(IncrementalTransfer(
-          requestor, target, property, it->second, 0, timeout));
+      std::unique_ptr<IncrementalTransfer> incremental_transfer(
+          new IncrementalTransfer(requestor, target, property,
+                                  base::WrapUnique(new XScopedEventSelector(

[dcheng, 2017/02/17 07:42:13]

Nit: base::MakeUnique

[pkotwicz, 2017/02/17 19:19:07]

Done.

+                                      requestor, PropertyChangeMask)),
+                                  it->second, 0, timeout));
+      incremental_transfers_.push_back(std::move(incremental_transfer));
 
       // Start a timer to abort the data transfer in case that the selection
       // requestor does not support the INCR property or gets destroyed during
       // the data transfer.
       if (!incremental_transfer_abort_timer_.IsRunning()) {
         incremental_transfer_abort_timer_.Start(
             FROM_HERE,
             base::TimeDelta::FromMilliseconds(kTimerPeriodMs),
             this,
             &SelectionOwner::AbortStaleIncrementalTransfers);
@@ skipping 38 matching lines @@
   // transfer->data once the zero-sized chunk is sent to indicate that state
   // related to this data transfer can be cleared.
   if (chunk_length == 0)
     transfer->data = NULL;
 }
 
 void SelectionOwner::AbortStaleIncrementalTransfers() {
   base::TimeTicks now = base::TimeTicks::Now();
   for (int i = static_cast<int>(incremental_transfers_.size()) - 1;
        i >= 0; --i) {
-    if (incremental_transfers_[i].timeout <= now)
+    if (incremental_transfers_[i]->timeout <= now)
       CompleteIncrementalTransfer(incremental_transfers_.begin() + i);
   }
 }
 
-void SelectionOwner::CompleteIncrementalTransfer(
-    std::vector<IncrementalTransfer>::iterator it) {
-  requestor_events_.reset();

[dcheng, 2017/02/17 07:42:13]

Is it possible to just only reset this when transfers is empty()?

[pkotwicz, 2017/02/17 19:19:07]

Unfortunately, there may be multiple requesting apps doing incremental transfers
from the clipboard.

XScopedEventSelector() start listening for PropertyNotify events on the
requesting app's window.

-
+void SelectionOwner::CompleteIncrementalTransfer(IncrementalTransferIt it) {
   incremental_transfers_.erase(it);
 
   if (incremental_transfers_.empty())
     incremental_transfer_abort_timer_.Stop();
 }
 
-std::vector<SelectionOwner::IncrementalTransfer>::iterator
-    SelectionOwner::FindIncrementalTransferForEvent(const XEvent& event) {
-  for (std::vector<IncrementalTransfer>::iterator it =
-           incremental_transfers_.begin();
-       it != incremental_transfers_.end();
-       ++it) {
-    if (it->window == event.xproperty.window &&
-        it->property == event.xproperty.atom) {
+SelectionOwner::IncrementalTransferIt
+SelectionOwner::FindIncrementalTransferForEvent(const XEvent& event) {
+  for (IncrementalTransferIt it = incremental_transfers_.begin();
+       it != incremental_transfers_.end(); ++it) {
+    IncrementalTransfer* incremental_transfer = (*it).get();

[dcheng, 2017/02/17 07:42:13]

Nit: Does it->get() work?

[pkotwicz, 2017/02/17 19:19:07]

Done.

+    if (incremental_transfer->window == event.xproperty.window &&
+        incremental_transfer->property == event.xproperty.atom) {
       return it;
     }
   }
   return incremental_transfers_.end();
 }
 
 SelectionOwner::IncrementalTransfer::IncrementalTransfer(
     XID window,
     XAtom target,
     XAtom property,
+    std::unique_ptr<XScopedEventSelector> event_selector,
     const scoped_refptr<base::RefCountedMemory>& data,
     int offset,
     base::TimeTicks timeout)
     : window(window),
       target(target),
       property(property),
+      event_selector(std::move(event_selector)),
       data(data),
       offset(offset),
       timeout(timeout) {}
 
-SelectionOwner::IncrementalTransfer::IncrementalTransfer(
-    const IncrementalTransfer& other) = default;
-
 SelectionOwner::IncrementalTransfer::~IncrementalTransfer() {
 }
 
 }  // namespace ui