ui/base/x/selection_requestor.cc

   1 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "ui/base/x/selection_requestor.h"
   6
   7 #include <algorithm>
   8 #include <X11/Xlib.h>
   9
  10 #include "base/run_loop.h"
  11 #include "ui/base/x/selection_utils.h"
  12 #include "ui/base/x/x11_util.h"
  13 #include "ui/events/platform/platform_event_dispatcher.h"
  14 #include "ui/events/platform/platform_event_source.h"
  15 #include "ui/gfx/x/x11_types.h"
  16
  17 namespace ui {
  18
  19 namespace {
  20
  21 const char kChromeSelection[] = "CHROME_SELECTION";
  22 const char kIncr[] = "INCR";
  23
  24 const char* kAtomsToCache[] = {
  25   kChromeSelection,
  26   kIncr,
  27   NULL
  28 };
  29
  30 // The period of |abort_timer_|. Arbitrary but must be <= than
  31 // kRequestTimeoutMs.
  32 const int kTimerPeriodMs = 100;
  33
  34 // The amount of time to wait for a request to complete before aborting it.
  35 const int kRequestTimeoutMs = 10000;
  36
  37 static_assert(kTimerPeriodMs <= kRequestTimeoutMs,
  38               "timer period must be <= request timeout");
  39
  40 // Combines |data| into a single RefCountedMemory object.
  41 scoped_refptr<base::RefCountedMemory> CombineRefCountedMemory(
  42     const std::vector<scoped_refptr<base::RefCountedMemory> >& data) {
  43   if (data.size() == 1u)
  44     return data[0];
  45
  46   size_t length = 0;
  47   for (size_t i = 0; i < data.size(); ++i)
  48     length += data[i]->size();
  49   std::vector<unsigned char> combined_data;
  50   combined_data.reserve(length);
  51
  52   for (size_t i = 0; i < data.size(); ++i) {
  53     combined_data.insert(combined_data.end(),
  54                          data[i]->front(),
  55                          data[i]->front() + data[i]->size());
  56   }
  57   return scoped_refptr<base::RefCountedMemory>(
  58       base::RefCountedBytes::TakeVector(&combined_data));
  59 }
  60
  61 }  // namespace
  62
  63 SelectionRequestor::SelectionRequestor(XDisplay* x_display,
  64                                        XID x_window,
  65                                        PlatformEventDispatcher* dispatcher)
  66     : x_display_(x_display),
  67       x_window_(x_window),
  68       x_property_(None),
  69       dispatcher_(dispatcher),
  70       current_request_index_(0u),
  71       atom_cache_(x_display_, kAtomsToCache) {
  72   x_property_ = atom_cache_.GetAtom(kChromeSelection);
  73 }
  74
  75 SelectionRequestor::~SelectionRequestor() {}
  76
  77 bool SelectionRequestor::PerformBlockingConvertSelection(
  78     XAtom selection,
  79     XAtom target,
  80     scoped_refptr<base::RefCountedMemory>* out_data,
  81     size_t* out_data_items,
  82     XAtom* out_type) {
  83   base::TimeTicks timeout =
  84       base::TimeTicks::Now() +
  85       base::TimeDelta::FromMilliseconds(kRequestTimeoutMs);
  86   Request request(selection, target, timeout);
  87   requests_.push_back(&request);
  88   if (current_request_index_ == (requests_.size() - 1))
  89     ConvertSelectionForCurrentRequest();
  90   BlockTillSelectionNotifyForRequest(&request);
  91
  92   std::vector<Request*>::iterator request_it = std::find(
  93       requests_.begin(), requests_.end(), &request);
  94   CHECK(request_it != requests_.end());
  95   if (static_cast<int>(current_request_index_) >
  96       request_it - requests_.begin()) {
  97     --current_request_index_;
  98   }
  99   requests_.erase(request_it);
 100
 101   if (requests_.empty())
 102     abort_timer_.Stop();
 103
 104   if (request.success) {
 105     if (out_data)
 106       *out_data = CombineRefCountedMemory(request.out_data);
 107     if (out_data_items)
 108       *out_data_items = request.out_data_items;
 109     if (out_type)
 110       *out_type = request.out_type;
 111   }
 112   return request.success;
 113 }
 114
 115 void SelectionRequestor::PerformBlockingConvertSelectionWithParameter(
 116     XAtom selection,
 117     XAtom target,
 118     const std::vector<XAtom>& parameter) {
 119   SetAtomArrayProperty(x_window_, kChromeSelection, "ATOM", parameter);
 120   PerformBlockingConvertSelection(selection, target, NULL, NULL, NULL);
 121 }
 122
 123 SelectionData SelectionRequestor::RequestAndWaitForTypes(
 124     XAtom selection,
 125     const std::vector<XAtom>& types) {
 126   for (std::vector<XAtom>::const_iterator it = types.begin();
 127        it != types.end(); ++it) {
 128     scoped_refptr<base::RefCountedMemory> data;
 129     XAtom type = None;
 130     if (PerformBlockingConvertSelection(selection,
 131                                         *it,
 132                                         &data,
 133                                         NULL,
 134                                         &type) &&
 135         type == *it) {
 136       return SelectionData(type, data);
 137     }
 138   }
 139
 140   return SelectionData();
 141 }
 142
 143 void SelectionRequestor::OnSelectionNotify(const XEvent& event) {
 144   Request* request = GetCurrentRequest();
 145   XAtom event_property = event.xselection.property;
 146   if (!request ||
 147       request->completed ||
 148       request->selection != event.xselection.selection ||
 149       request->target != event.xselection.target) {
 150     // ICCCM requires us to delete the property passed into SelectionNotify.
 151     if (event_property != None)
 152       XDeleteProperty(x_display_, x_window_, event_property);
 153     return;
 154   }
 155
 156   bool success = false;
 157   if (event_property == x_property_) {
 158     scoped_refptr<base::RefCountedMemory> out_data;
 159     success = ui::GetRawBytesOfProperty(x_window_,
 160                                         x_property_,
 161                                         &out_data,
 162                                         &request->out_data_items,
 163                                         &request->out_type);
 164     if (success) {
 165       request->out_data.clear();
 166       request->out_data.push_back(out_data);
 167     }
 168   }
 169   if (event_property != None)
 170     XDeleteProperty(x_display_, x_window_, event_property);
 171
 172   if (request->out_type == atom_cache_.GetAtom(kIncr)) {
 173     request->data_sent_incrementally = true;
 174     request->out_data.clear();
 175     request->out_data_items = 0u;
 176     request->out_type = None;
 177     request->timeout = base::TimeTicks::Now() +
 178         base::TimeDelta::FromMilliseconds(kRequestTimeoutMs);
 179   } else {
 180     CompleteRequest(current_request_index_, success);
 181   }
 182 }
 183
 184 bool SelectionRequestor::CanDispatchPropertyEvent(const XEvent& event) {
 185   return event.xproperty.window == x_window_ &&
 186       event.xproperty.atom == x_property_ &&
 187       event.xproperty.state == PropertyNewValue;
 188 }
 189
 190 void SelectionRequestor::OnPropertyEvent(const XEvent& event) {
 191   Request* request = GetCurrentRequest();
 192   if (!request || !request->data_sent_incrementally)
 193     return;
 194
 195   scoped_refptr<base::RefCountedMemory> out_data;
 196   size_t out_data_items = 0u;
 197   Atom out_type = None;
 198   bool success = ui::GetRawBytesOfProperty(x_window_,
 199                                            x_property_,
 200                                            &out_data,
 201                                            &out_data_items,
 202                                            &out_type);
 203   if (!success) {
 204     CompleteRequest(current_request_index_, false);
 205     return;
 206   }
 207
 208   if (request->out_type != None && request->out_type != out_type) {
 209     CompleteRequest(current_request_index_, false);
 210     return;
 211   }
 212
 213   request->out_data.push_back(out_data);
 214   request->out_data_items += out_data_items;
 215   request->out_type = out_type;
 216
 217   // Delete the property to tell the selection owner to send the next chunk.
 218   XDeleteProperty(x_display_, x_window_, x_property_);
 219
 220   request->timeout = base::TimeTicks::Now() +
 221       base::TimeDelta::FromMilliseconds(kRequestTimeoutMs);
 222
 223   if (out_data->size() == 0u)
 224     CompleteRequest(current_request_index_, true);
 225 }
 226
 227 void SelectionRequestor::AbortStaleRequests() {
 228   base::TimeTicks now = base::TimeTicks::Now();
 229   for (size_t i = current_request_index_; i < requests_.size(); ++i) {
 230     if (requests_[i]->timeout <= now)
 231       CompleteRequest(i, false);
 232   }
 233 }
 234
 235 void SelectionRequestor::CompleteRequest(size_t index, bool success) {
 236    if (index >= requests_.size())
 237      return;
 238
 239   Request* request = requests_[index];
 240   if (request->completed)
 241     return;
 242   request->success = success;
 243   request->completed = true;
 244
 245   if (index == current_request_index_) {
 246     while (GetCurrentRequest() && GetCurrentRequest()->completed)
 247       ++current_request_index_;
 248     ConvertSelectionForCurrentRequest();
 249   }
 250
 251   if (!request->quit_closure.is_null())
 252     request->quit_closure.Run();
 253 }
 254
 255 void SelectionRequestor::ConvertSelectionForCurrentRequest() {
 256   Request* request = GetCurrentRequest();
 257   if (request) {
 258     XConvertSelection(x_display_,
 259                       request->selection,
 260                       request->target,
 261                       x_property_,
 262                       x_window_,
 263                       CurrentTime);
 264   }
 265 }
 266
 267 void SelectionRequestor::BlockTillSelectionNotifyForRequest(Request* request) {
 268   if (PlatformEventSource::GetInstance()) {
 269     if (!abort_timer_.IsRunning()) {
 270       abort_timer_.Start(FROM_HERE,
 271                          base::TimeDelta::FromMilliseconds(kTimerPeriodMs),
 272                          this,
 273                          &SelectionRequestor::AbortStaleRequests);
 274     }
 275
 276     base::MessageLoop::ScopedNestableTaskAllower allow_nested(
 277         base::MessageLoopForUI::current());
 278     base::RunLoop run_loop;
 279     request->quit_closure = run_loop.QuitClosure();
 280     run_loop.Run();
 281
 282     // We cannot put logic to process the next request here because the RunLoop
 283     // might be nested. For instance, request 'B' may start a RunLoop while the
 284     // RunLoop for request 'A' is running. It is not possible to end the RunLoop
 285     // for request 'A' without first ending the RunLoop for request 'B'.
 286   } else {
 287     // This occurs if PerformBlockingConvertSelection() is called during
 288     // shutdown and the PlatformEventSource has already been destroyed.
 289     while (!request->completed &&
 290            request->timeout > base::TimeTicks::Now()) {
 291       if (XPending(x_display_)) {
 292         XEvent event;
 293         XNextEvent(x_display_, &event);
 294         dispatcher_->DispatchEvent(&event);
 295       }
 296     }
 297   }
 298 }
 299
 300 SelectionRequestor::Request* SelectionRequestor::GetCurrentRequest() {
 301   return current_request_index_ == requests_.size() ?
 302       NULL : requests_[current_request_index_];
 303 }
 304
 305 SelectionRequestor::Request::Request(XAtom selection,
 306                                      XAtom target,
 307                                      base::TimeTicks timeout)
 308     : selection(selection),
 309       target(target),
 310       data_sent_incrementally(false),
 311       out_data_items(0u),
 312       out_type(None),
 313       success(false),
 314       timeout(timeout),
 315       completed(false) {
 316 }
 317
 318 SelectionRequestor::Request::~Request() {
 319 }
 320
 321 }  // namespace ui