SelectionOwner: add support for TIMESTAMP target

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 "ui/base/x/selection_utils.h"
 #include "ui/base/x/x11_foreign_window_manager.h"
 #include "ui/base/x/x11_util.h"
+#include "ui/events/platform/x11/x11_event_source.h"
 
 namespace ui {
 
 namespace {
 
 const char kAtomPair[] = "ATOM_PAIR";
 const char kIncr[] = "INCR";
 const char kMultiple[] = "MULTIPLE";
 const char kSaveTargets[] = "SAVE_TARGETS";
 const char kTargets[] = "TARGETS";
+const char kTimestamp[] = "TIMESTAMP";
 
-const char* kAtomsToCache[] = {
-  kAtomPair,
-  kIncr,
-  kMultiple,
-  kSaveTargets,
-  kTargets,
-  NULL
-};
+const char* kAtomsToCache[] = {kAtomPair, kIncr,      kMultiple, kSaveTargets,
+                               kTargets,  kTimestamp, NULL};
 
 // The period of |incremental_transfer_abort_timer_|. Arbitrary but must be <=
 // than kIncrementalTransferTimeoutMs.
 const int kTimerPeriodMs = 1000;
 
 // The amount of time to wait for the selection requestor to process the data
 // sent by the selection owner before aborting an incremental data transfer.
 const int kIncrementalTransferTimeoutMs = 10000;
 
 static_assert(kTimerPeriodMs <= kIncrementalTransferTimeoutMs,
@@ skipping 71 matching lines @@
 
 void SelectionOwner::RetrieveTargets(std::vector<XAtom>* targets) {
   for (SelectionFormatMap::const_iterator it = format_map_.begin();
        it != format_map_.end(); ++it) {
     targets->push_back(it->first);
   }
 }
 
 void SelectionOwner::TakeOwnershipOfSelection(
     const SelectionFormatMap& data) {
+  // Save the last server timestamp seen from X, to satisfy requests for the
+  // TIMESTAMP target later…
+  acquired_selection_timestamp_ =
+      X11EventSource::GetInstance()->last_seen_server_time();
+  // …but always pass CurrentTime to XSetSelectionOwner to increase the chances
+  // of this succeeding.
   XSetSelectionOwner(x_display_, selection_name_, x_window_, CurrentTime);
 
   if (XGetSelectionOwner(x_display_, selection_name_) == x_window_) {
     // The X server agrees that we are the selection owner. Commit our data.
     format_map_ = data;
   }
 }
 
 void SelectionOwner::ClearSelectionOwner() {
   XSetSelectionOwner(x_display_, selection_name_, None, CurrentTime);
@@ skipping 77 matching lines @@
   if (!it->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);
 
   if (target == multiple_atom || target == save_targets_atom)
     return false;
 
+  if (target == timestamp_atom) {
+    XChangeProperty(
+        x_display_, requestor, property, XA_INTEGER, 32, PropModeReplace,
+        reinterpret_cast<unsigned char*>(&acquired_selection_timestamp_), 1);
+    return true;
+  }
+
   if (target == targets_atom) {
     // We have been asked for TARGETS. Send an atom array back with the data
     // types we support.
     std::vector<XAtom> targets;
+    targets.push_back(timestamp_atom);
     targets.push_back(targets_atom);
     targets.push_back(save_targets_atom);
     targets.push_back(multiple_atom);
     RetrieveTargets(&targets);
 
     XChangeProperty(x_display_, requestor, property, XA_ATOM, 32,
                     PropModeReplace,
                     reinterpret_cast<unsigned char*>(&targets.front()),
                     targets.size());
     return true;
-  } else {
-    // Try to find the data type in map.
-    SelectionFormatMap::const_iterator it = format_map_.find(target);
-    if (it != format_map_.end()) {
-      if (it->second->size() > max_request_size_) {
-        // We must send the data back in several chunks due to a limitation in
-        // the size of X requests. Notify the selection requestor that the data
-        // will be sent incrementally by returning data of type "INCR".
-        long length = it->second->size();
-        XChangeProperty(x_display_,
-                        requestor,
-                        property,
-                        atom_cache_.GetAtom(kIncr),
-                        32,
-                        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);
-        int foreign_window_manager_id =
-            ui::XForeignWindowManager::GetInstance()->RequestEvents(
-                requestor, PropertyChangeMask);
-        incremental_transfers_.push_back(
-            IncrementalTransfer(requestor,
-                                target,
-                                property,
-                                it->second,
-                                0,
-                                timeout,
-                                foreign_window_manager_id));
+  // Try to find the data type in map.
+  SelectionFormatMap::const_iterator it = format_map_.find(target);
+  if (it != format_map_.end()) {
+    if (it->second->size() > max_request_size_) {
+      // We must send the data back in several chunks due to a limitation in
+      // the size of X requests. Notify the selection requestor that the data
+      // will be sent incrementally by returning data of type "INCR".
+      long length = it->second->size();
+      XChangeProperty(x_display_,
+                      requestor,
+                      property,
+                      atom_cache_.GetAtom(kIncr),
+                      32,
+                      PropModeReplace,
+                      reinterpret_cast<unsigned char*>(&length),
+                      1);
 
-        // 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);
-        }
-      } else {
-        XChangeProperty(
-            x_display_,
-            requestor,
-            property,
-            target,
-            8,
-            PropModeReplace,
-            const_cast<unsigned char*>(it->second->front()),
-            it->second->size());
+      // 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);
+      int foreign_window_manager_id =
+          ui::XForeignWindowManager::GetInstance()->RequestEvents(
+              requestor, PropertyChangeMask);
+      incremental_transfers_.push_back(
+          IncrementalTransfer(requestor,
+                              target,
+                              property,
+                              it->second,
+                              0,
+                              timeout,
+                              foreign_window_manager_id));
+
+      // 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);
       }
-      return true;
+    } else {
+      XChangeProperty(
+          x_display_,
+          requestor,
+          property,
+          target,
+          8,
+          PropModeReplace,
+          const_cast<unsigned char*>(it->second->front()),
+          it->second->size());
     }
-    // I would put error logging here, but GTK ignores TARGETS and spams us
-    // looking for its own internal types.
+    return true;
   }
+
+  // I would put error logging here, but GTK ignores TARGETS and spams us
+  // looking for its own internal types.
   return false;
 }
 
 void SelectionOwner::ProcessIncrementalTransfer(IncrementalTransfer* transfer) {
   size_t remaining = transfer->data->size() - transfer->offset;
   size_t chunk_length = std::min(remaining, max_request_size_);
   XChangeProperty(
       x_display_,
       transfer->window,
       transfer->property,
@@ skipping 64 matching lines @@
       foreign_window_manager_id(foreign_window_manager_id) {
 }
 
 SelectionOwner::IncrementalTransfer::IncrementalTransfer(
     const IncrementalTransfer& other) = default;
 
 SelectionOwner::IncrementalTransfer::~IncrementalTransfer() {
 }
 
 }  // namespace ui