[Refactor]: Move drag_widget_ out of X11WholeScreenMoveLoop

ui/views/widget/desktop_aura/x11_whole_screen_move_loop.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/x11_whole_screen_move_loop.h"
 
 #include <X11/Xlib.h>
-// Get rid of a macro from Xlib.h that conflicts with Aura's RootWindow class.
-#undef RootWindow
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
-#include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/aura/env.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_event_dispatcher.h"
 #include "ui/aura/window_tree_host.h"
 #include "ui/base/x/x11_util.h"
 #include "ui/events/event.h"
 #include "ui/events/event_utils.h"
 #include "ui/events/keycodes/keyboard_code_conversion_x.h"
 #include "ui/events/platform/scoped_event_dispatcher.h"
 #include "ui/events/platform/x11/x11_event_source.h"
 #include "ui/gfx/point_conversions.h"
-#include "ui/gfx/screen.h"
-#include "ui/views/controls/image_view.h"
-#include "ui/views/widget/widget.h"
 
 namespace views {
 
 namespace {
 
-// The minimum alpha before we declare a pixel transparent when searching in
-// our source image.
-const uint32 kMinAlpha = 32;
-const unsigned char kDragWidgetOpacity = 0xc0;
-
 class ScopedCapturer {
  public:
   explicit ScopedCapturer(aura::WindowTreeHost* host)
       : host_(host) {
     host_->SetCapture();
   }
 
   ~ScopedCapturer() {
     host_->ReleaseCapture();
   }
@@ skipping 44 matching lines @@
   // event that should have stopped the drag even if that mouse release happened
   // before the grab was granted.
   if (!in_move_loop_)
     return ui::POST_DISPATCH_PERFORM_DEFAULT;
   XEvent* xev = event;
 
   // Note: the escape key is handled in the tab drag controller, which has
   // keyboard focus even though we took pointer grab.
   switch (xev->type) {
     case MotionNotify: {
-      if (drag_widget_.get()) {
-        gfx::Screen* screen = gfx::Screen::GetNativeScreen();
-        gfx::Point location = gfx::ToFlooredPoint(
-            screen->GetCursorScreenPoint() - drag_offset_);
-        drag_widget_->SetBounds(gfx::Rect(location, drag_image_.size()));
-        drag_widget_->StackAtTop();
-      }
       last_xmotion_ = xev->xmotion;
       if (!weak_factory_.HasWeakPtrs()) {
         // Post a task to dispatch mouse movement event when control returns to
         // the message loop. This allows smoother dragging since the events are
         // dispatched without waiting for the drag widget updates.
         base::MessageLoopForUI::current()->PostTask(
             FROM_HERE,
             base::Bind(&X11WholeScreenMoveLoop::DispatchMouseMovement,
                        weak_factory_.GetWeakPtr()));
       }
@@ skipping 79 matching lines @@
   // ScopedCapturer to avoid possibility of logically keeping multiple grabs.
   if (!GrabPointerAndKeyboard(cursor)) {
     XDestroyWindow(gfx::GetXDisplay(), grab_input_window_);
     return false;
   }
 
   scoped_ptr<ui::ScopedEventDispatcher> old_dispatcher =
       nested_dispatcher_.Pass();
   nested_dispatcher_ =
          ui::PlatformEventSource::GetInstance()->OverrideDispatcher(this);
-  if (!drag_image_.isNull() && CheckIfIconValid())
-    CreateDragImageWindow();
 
   // We are handling a mouse drag outside of the aura::RootWindow system. We
   // must manually make aura think that the mouse button is pressed so that we
   // don't draw extraneous tooltips.
   aura::Env* env = aura::Env::GetInstance();
   if (!env->IsMouseButtonDown()) {
     env->set_mouse_button_flags(ui::EF_LEFT_MOUSE_BUTTON);
     should_reset_mouse_flags_ = true;
   }
 
@@ skipping 38 matching lines @@
   // Ungrab before we let go of the window.
   XDisplay* display = gfx::GetXDisplay();
   // Only ungrab pointer if capture was not switched to another window.
   if (has_grab_) {
     XUngrabPointer(display, CurrentTime);
     XUngrabKeyboard(display, CurrentTime);
   }
 
   // Restore the previous dispatcher.
   nested_dispatcher_.reset();
-  drag_widget_.reset();
   delegate_->OnMoveLoopEnded();
   XDestroyWindow(display, grab_input_window_);
   grab_input_window_ = None;
 
   in_move_loop_ = false;
   quit_closure_.Run();
 }
 
-void X11WholeScreenMoveLoop::SetDragImage(const gfx::ImageSkia& image,
-                                          const gfx::Vector2dF& offset) {
-  drag_image_ = image;
-  drag_offset_ = offset;
-}
-
 bool X11WholeScreenMoveLoop::GrabPointerAndKeyboard(gfx::NativeCursor cursor) {
   XDisplay* display = gfx::GetXDisplay();
   XGrabServer(display);
 
   XUngrabPointer(display, CurrentTime);
   int ret = XGrabPointer(
       display,
       grab_input_window_,
       False,
       ButtonPressMask | ButtonReleaseMask | PointerMotionMask,
@@ skipping 41 matching lines @@
   Window window = XCreateWindow(display,
                                 DefaultRootWindow(display),
                                 -100, -100, 10, 10,
                                 0, CopyFromParent, InputOnly, CopyFromParent,
                                 attribute_mask, &swa);
   XMapRaised(display, window);
   ui::X11EventSource::GetInstance()->BlockUntilWindowMapped(window);
   return window;
 }
 
-void X11WholeScreenMoveLoop::CreateDragImageWindow() {
-  Widget* widget = new Widget;
-  Widget::InitParams params(Widget::InitParams::TYPE_DRAG);
-  params.opacity = Widget::InitParams::OPAQUE_WINDOW;
-  params.ownership = Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
-  params.accept_events = false;
-
-  gfx::Point location = gfx::ToFlooredPoint(
-      gfx::Screen::GetNativeScreen()->GetCursorScreenPoint() - drag_offset_);
-  params.bounds = gfx::Rect(location, drag_image_.size());
-  widget->set_focus_on_creation(false);
-  widget->set_frame_type(Widget::FRAME_TYPE_FORCE_NATIVE);
-  widget->Init(params);
-  widget->SetOpacity(kDragWidgetOpacity);
-  widget->GetNativeWindow()->SetName("DragWindow");
-
-  ImageView* image = new ImageView();
-  image->SetImage(drag_image_);
-  image->SetBounds(0, 0, drag_image_.width(), drag_image_.height());
-  widget->SetContentsView(image);
-  widget->Show();
-  widget->GetNativeWindow()->layer()->SetFillsBoundsOpaquely(false);
-
-  drag_widget_.reset(widget);
-}
-
-bool X11WholeScreenMoveLoop::CheckIfIconValid() {
-  // Because we need a GL context per window, we do a quick check so that we
-  // don't make another context if the window would just be displaying a mostly
-  // transparent image.
-  const SkBitmap* in_bitmap = drag_image_.bitmap();
-  SkAutoLockPixels in_lock(*in_bitmap);
-  for (int y = 0; y < in_bitmap->height(); ++y) {
-    uint32* in_row = in_bitmap->getAddr32(0, y);
-
-    for (int x = 0; x < in_bitmap->width(); ++x) {
-      if (SkColorGetA(in_row[x]) > kMinAlpha)
-        return true;
-    }
-  }
-
-  return false;
-}
-
 }  // namespace views