linux_aura: Implement dropping in chrome.

ui/views/widget/desktop_aura/desktop_root_window_host_x11.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/views/widget/desktop_aura/desktop_root_window_host_x11.h"
 
 #include <X11/extensions/XInput2.h>
 #include <X11/Xatom.h>
 #include <X11/Xutil.h>
 
 #include "base/message_pump_aurax11.h"
 #include "base/stringprintf.h"
 #include "base/utf_string_conversions.h"
 #include "ui/aura/client/screen_position_client.h"
 #include "ui/aura/client/user_action_client.h"
 #include "ui/aura/focus_manager.h"
 #include "ui/aura/root_window.h"
 #include "ui/aura/window_property.h"
+#include "ui/base/dragdrop/os_exchange_data_provider_aurax11.h"
 #include "ui/base/events/event_utils.h"
 #include "ui/base/touch/touch_factory_x11.h"
 #include "ui/base/x/x11_util.h"
 #include "ui/gfx/insets.h"
 #include "ui/linux_ui/linux_ui.h"
 #include "ui/native_theme/native_theme.h"
 #include "ui/views/corewm/compound_event_filter.h"
 #include "ui/views/corewm/corewm_switches.h"
 #include "ui/views/corewm/cursor_manager.h"
 #include "ui/views/corewm/focus_controller.h"
 #include "ui/views/ime/input_method.h"
 #include "ui/views/widget/desktop_aura/desktop_activation_client.h"
 #include "ui/views/widget/desktop_aura/desktop_capture_client.h"
 #include "ui/views/widget/desktop_aura/desktop_cursor_loader_updater_aurax11.h"
 #include "ui/views/widget/desktop_aura/desktop_dispatcher_client.h"
+#include "ui/views/widget/desktop_aura/desktop_drag_drop_client_aurax11.h"
 #include "ui/views/widget/desktop_aura/desktop_focus_rules.h"
 #include "ui/views/widget/desktop_aura/desktop_layout_manager.h"
 #include "ui/views/widget/desktop_aura/desktop_native_cursor_manager.h"
 #include "ui/views/widget/desktop_aura/desktop_native_widget_aura.h"
 #include "ui/views/widget/desktop_aura/desktop_screen_position_client.h"
 #include "ui/views/widget/desktop_aura/x11_desktop_handler.h"
 #include "ui/views/widget/desktop_aura/x11_desktop_window_move_client.h"
 #include "ui/views/widget/desktop_aura/x11_window_event_filter.h"
 
 namespace views {
@@ skipping 12 matching lines @@
 // Standard Linux mouse buttons for going back and forward.
 const int kBackMouseButton = 8;
 const int kForwardMouseButton = 9;
 
 // Constants that are part of EWMH.
 const int k_NET_WM_STATE_ADD = 1;
 const int k_NET_WM_STATE_REMOVE = 0;
 
 const char* kAtomsToCache[] = {
   "WM_DELETE_WINDOW",
+  "WM_PROTOCOLS",
   "WM_S0",
   "_NET_WM_PID",
   "_NET_WM_PING",
   "_NET_WM_STATE",
   "_NET_WM_STATE_FULLSCREEN",
   "_NET_WM_STATE_HIDDEN",
   "_NET_WM_STATE_MAXIMIZED_HORZ",
   "_NET_WM_STATE_MAXIMIZED_VERT",
+  "XdndActionAsk",
+  "XdndActionCopy"
+  "XdndActionLink",
+  "XdndActionList",
+  "XdndActionMove",
+  "XdndActionPrivate",
+  "XdndAware",
+  "XdndDrop",
+  "XdndEnter",
+  "XdndFinished",
+  "XdndLeave",
+  "XdndPosition",
+  "XdndProxy",  // Proxy windows?
+  "XdndSelection",
+  "XdndStatus",
+  "XdndTypeList",
   NULL
 };
 
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 // DesktopRootWindowHostX11, public:
 
 DesktopRootWindowHostX11::DesktopRootWindowHostX11(
     internal::NativeWidgetDelegate* native_widget_delegate,
     DesktopNativeWidgetAura* desktop_native_widget_aura,
     const gfx::Rect& initial_bounds)
     : close_widget_factory_(this),
       xdisplay_(base::MessagePumpAuraX11::GetDefaultXDisplay()),
       xwindow_(0),
       x_root_window_(DefaultRootWindow(xdisplay_)),
       atom_cache_(xdisplay_, kAtomsToCache),
       window_mapped_(false),
       focus_when_shown_(false),
       current_cursor_(ui::kCursorNull),
       native_widget_delegate_(native_widget_delegate),
-      desktop_native_widget_aura_(desktop_native_widget_aura) {
+      desktop_native_widget_aura_(desktop_native_widget_aura),
+      drop_handler_(NULL) {
 }
 
 DesktopRootWindowHostX11::~DesktopRootWindowHostX11() {
   root_window_->ClearProperty(kHostForRootWindow);
   if (corewm::UseFocusControllerOnDesktop()) {
     aura::client::SetFocusClient(root_window_, NULL);
     aura::client::SetActivationClient(root_window_, NULL);
   }
 }
 
@@ skipping 149 matching lines @@
                       new DesktopCursorLoaderUpdaterAuraX11)))));
   aura::client::SetCursorClient(root_window_,
                                 cursor_client_.get());
 
   position_client_.reset(new DesktopScreenPositionClient);
   aura::client::SetScreenPositionClient(root_window_,
                                         position_client_.get());
 
   desktop_native_widget_aura_->InstallInputMethodEventFilter(root_window_);
 
+  drag_drop_client_.reset(new DesktopDragDropClientAuraX11(
+      this, root_window_, xdisplay_, xwindow_));
+  aura::client::SetDragDropClient(root_window_, drag_drop_client_.get());
+
   // TODO(erg): Unify this code once the other consumer goes away.
   x11_window_event_filter_.reset(
       new X11WindowEventFilter(root_window_, activation_client_.get()));
   x11_window_event_filter_->SetUseHostWindowBorders(false);
   desktop_native_widget_aura_->root_window_event_filter()->AddHandler(
       x11_window_event_filter_.get());
 
   x11_window_move_client_.reset(new X11DesktopWindowMoveClient);
   aura::client::SetWindowMoveClient(root_window_,
                                     x11_window_move_client_.get());
@@ skipping 603 matching lines @@
 }
 
 void DesktopRootWindowHostX11::OnDeviceScaleFactorChanged(
     float device_scale_factor) {
 }
 
 void DesktopRootWindowHostX11::PrepareForShutdown() {
 }
 
 ////////////////////////////////////////////////////////////////////////////////
+// DesktopRootWindowHostX11, ui::DesktopSelectionProviderAuraX11 implementation:
+
+void DesktopRootWindowHostX11::SetDropHandler(
+    ui::OSExchangeDataProviderAuraX11* handler) {
+  if (handler) {
+    DCHECK(!drop_handler_);
+    drop_handler_ = handler;
+  } else {
+    DCHECK(drop_handler_);
+    drop_handler_ = NULL;
+  }
+}
+
+////////////////////////////////////////////////////////////////////////////////
 // DesktopRootWindowHostX11, MessageLoop::Dispatcher implementation:
 
 bool DesktopRootWindowHostX11::Dispatch(const base::NativeEvent& event) {
   XEvent* xev = event;
 
   // May want to factor CheckXEventForConsistency(xev); into a common location
   // since it is called here.
   switch (xev->type) {
     case Expose:
       // TODO(erg): Can we only redraw the affected areas?
@@ skipping 141 matching lines @@
       break;
     }
     case MapNotify: {
       // If there's no window manager running, we need to assign the X input
       // focus to our host window.
       if (!IsWindowManagerPresent() && focus_when_shown_)
         XSetInputFocus(xdisplay_, xwindow_, RevertToNone, CurrentTime);
       break;
     }
     case ClientMessage: {
-      Atom message_type = static_cast<Atom>(xev->xclient.data.l[0]);
-      if (message_type == atom_cache_.GetAtom("WM_DELETE_WINDOW")) {
-        // We have received a close message from the window manager.
-        root_window_->OnRootWindowHostCloseRequested();
-      } else if (message_type == atom_cache_.GetAtom("_NET_WM_PING")) {
-        XEvent reply_event = *xev;
-        reply_event.xclient.window = x_root_window_;
+      Atom message_type = xev->xclient.message_type;
+      if (message_type == atom_cache_.GetAtom("WM_PROTOCOLS")) {
+        Atom protocol = static_cast<Atom>(xev->xclient.data.l[0]);
+        if (protocol == atom_cache_.GetAtom("WM_DELETE_WINDOW")) {
+          // We have received a close message from the window manager.
+          root_window_->OnRootWindowHostCloseRequested();
+        } else if (protocol == atom_cache_.GetAtom("_NET_WM_PING")) {
+          XEvent reply_event = *xev;
+          reply_event.xclient.window = x_root_window_;
 
-        XSendEvent(xdisplay_,
-                   reply_event.xclient.window,
-                   False,
-                   SubstructureRedirectMask | SubstructureNotifyMask,
-                   &reply_event);
+          XSendEvent(xdisplay_,
+                     reply_event.xclient.window,
+                     False,
+                     SubstructureRedirectMask | SubstructureNotifyMask,
+                     &reply_event);
+        }
+      } else if (message_type == atom_cache_.GetAtom("XdndEnter")) {
+        drag_drop_client_->OnXdndEnter(xev->xclient);
+      } else if (message_type == atom_cache_.GetAtom("XdndLeave")) {
+        drag_drop_client_->OnXdndLeave(xev->xclient);
+      } else if (message_type == atom_cache_.GetAtom("XdndPosition")) {
+        drag_drop_client_->OnXdndPosition(xev->xclient);
+      } else if (message_type == atom_cache_.GetAtom("XdndStatus")) {
+        drag_drop_client_->OnXdndStatus(xev->xclient);
+      } else if (message_type == atom_cache_.GetAtom("XdndFinished")) {
+        drag_drop_client_->OnXdndFinished(xev->xclient);
+      } else if (message_type == atom_cache_.GetAtom("XdndDrop")) {
+        drag_drop_client_->OnXdndDrop(xev->xclient);
       }
       break;
     }
     case MappingNotify: {
       switch (xev->xmapping.request) {
         case MappingModifier:
         case MappingKeyboard:
           XRefreshKeyboardMapping(&xev->xmapping);
           root_window_->OnKeyboardMappingChanged();
           break;
@@ skipping 50 matching lines @@
         // fullscreen state. Unsure what to do about that.
         Widget* widget = native_widget_delegate_->AsWidget();
         NonClientView* non_client_view = widget->non_client_view();
         // non_client_view may be NULL, especially during creation.
         if (non_client_view) {
           non_client_view->client_view()->InvalidateLayout();
           non_client_view->InvalidateLayout();
         }
         widget->GetRootView()->Layout();
       }
+      break;
+    }
+    case SelectionNotify: {
+      if (drop_handler_)
+        drop_handler_->OnSelectionNotify(xev->xselection);
+      break;
     }
   }
   return true;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // DesktopRootWindowHost, public:
 
 // static
 DesktopRootWindowHost* DesktopRootWindowHost::Create(
     internal::NativeWidgetDelegate* native_widget_delegate,
     DesktopNativeWidgetAura* desktop_native_widget_aura,
     const gfx::Rect& initial_bounds) {
   return new DesktopRootWindowHostX11(native_widget_delegate,
                                         desktop_native_widget_aura,
                                         initial_bounds);
 }
 
 }  // namespace views