Refactor X11ForeignWindowManager (Reland)

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/base/x/x11_window_manager.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";
@@ skipping 237 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);
-      int foreign_window_manager_id =
-          ui::XForeignWindowManager::GetInstance()->RequestEvents(
-              requestor, PropertyChangeMask);
+      ui::XWindowManager::GetInstance()->SelectEvents(requestor,
+                                                      PropertyChangeMask);
       incremental_transfers_.push_back(
           IncrementalTransfer(requestor,
                               target,
                               property,
                               it->second,
                               0,
-                              timeout,
-                              foreign_window_manager_id));
+                              timeout));
 
       // 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 45 matching lines @@
   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)
       CompleteIncrementalTransfer(incremental_transfers_.begin() + i);
   }
 }
 
 void SelectionOwner::CompleteIncrementalTransfer(
     std::vector<IncrementalTransfer>::iterator it) {
-  ui::XForeignWindowManager::GetInstance()->CancelRequest(
-      it->foreign_window_manager_id);
+  ui::XWindowManager::GetInstance()->DeselectEvents(it->window,
+                                                    PropertyChangeMask);
   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) {
       return it;
     }
   }
   return incremental_transfers_.end();
 }
 
 SelectionOwner::IncrementalTransfer::IncrementalTransfer(
     XID window,
     XAtom target,
     XAtom property,
     const scoped_refptr<base::RefCountedMemory>& data,
     int offset,
-    base::TimeTicks timeout,
-    int foreign_window_manager_id)
+    base::TimeTicks timeout)
     : window(window),
       target(target),
       property(property),
       data(data),
       offset(offset),
-      timeout(timeout),
-      foreign_window_manager_id(foreign_window_manager_id) {
-}
+      timeout(timeout) {}
 
 SelectionOwner::IncrementalTransfer::IncrementalTransfer(
     const IncrementalTransfer& other) = default;
 
 SelectionOwner::IncrementalTransfer::~IncrementalTransfer() {
 }
 
 }  // namespace ui