xref: /external/chromium_org/content/browser/web_contents/web_drag_dest_gtk.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 "content/browser/web_contents/web_drag_dest_gtk.h"

#include <string>

#include "base/bind.h"
#include "base/files/file_path.h"
#include "base/message_loop/message_loop.h"
#include "base/strings/utf_string_conversions.h"
#include "content/browser/renderer_host/render_view_host_impl.h"
#include "content/browser/web_contents/drag_utils_gtk.h"
#include "content/browser/web_contents/web_contents_impl.h"
#include "content/public/browser/web_contents_delegate.h"
#include "content/public/browser/web_drag_dest_delegate.h"
#include "content/public/common/url_constants.h"
#include "net/base/net_util.h"
#include "third_party/WebKit/public/web/WebInputEvent.h"
#include "ui/base/clipboard/custom_data_helper.h"
#include "ui/base/dragdrop/gtk_dnd_util.h"
#include "ui/base/gtk/gtk_screen_util.h"

using blink::WebDragOperation;
using blink::WebDragOperationNone;

namespace content {

namespace {
const int kNumGtkHandlers = 5;

int GetModifierFlags(GtkWidget* widget) {
  int modifier_state = 0;
  GdkModifierType state;
  gdk_window_get_pointer(gtk_widget_get_window(widget), NULL, NULL, &state);

  if (state & GDK_SHIFT_MASK)
    modifier_state |= blink::WebInputEvent::ShiftKey;
  if (state & GDK_CONTROL_MASK)
    modifier_state |= blink::WebInputEvent::ControlKey;
  if (state & GDK_MOD1_MASK)
    modifier_state |= blink::WebInputEvent::AltKey;
  if (state & GDK_META_MASK)
    modifier_state |= blink::WebInputEvent::MetaKey;
  return modifier_state;
}

}  // namespace

WebDragDestGtk::WebDragDestGtk(WebContents* web_contents, GtkWidget* widget)
    : web_contents_(web_contents),
      widget_(widget),
      context_(NULL),
      data_requests_(0),
      delegate_(NULL),
      canceled_(false),
      method_factory_(this) {
  gtk_drag_dest_set(widget, static_cast<GtkDestDefaults>(0),
                    NULL, 0,
                    static_cast<GdkDragAction>(GDK_ACTION_COPY |
                                               GDK_ACTION_LINK |
                                               GDK_ACTION_MOVE));

  // If adding a handler, make sure to update kNumGtkHandlers and add it to the
  // |handlers_| array so that it can be disconnected later on.
  handlers_.reset(new int[kNumGtkHandlers]);
  handlers_.get()[0] = g_signal_connect(
      widget, "drag-motion", G_CALLBACK(OnDragMotionThunk), this);
  handlers_.get()[1] = g_signal_connect(
      widget, "drag-leave", G_CALLBACK(OnDragLeaveThunk), this);
  handlers_.get()[2] = g_signal_connect(
      widget, "drag-drop", G_CALLBACK(OnDragDropThunk), this);
  handlers_.get()[3] = g_signal_connect(
      widget, "drag-data-received", G_CALLBACK(OnDragDataReceivedThunk), this);
  // TODO(tony): Need a drag-data-delete handler for moving content out of
  // the WebContents.  http://crbug.com/38989

  handlers_.get()[4] = g_signal_connect(
      widget, "destroy", G_CALLBACK(gtk_widget_destroyed), &widget_);
}

WebDragDestGtk::~WebDragDestGtk() {
  if (widget_) {
    gtk_drag_dest_unset(widget_);
    for (int i = 0; i < kNumGtkHandlers; ++i)
      g_signal_handler_disconnect(widget_, handlers_.get()[i]);
  }
}

void WebDragDestGtk::UpdateDragStatus(WebDragOperation operation) {
  if (context_) {
    is_drop_target_ = operation != WebDragOperationNone;
    gdk_drag_status(context_, WebDragOpToGdkDragAction(operation),
                    drag_over_time_);
  }
}

void WebDragDestGtk::DragLeave() {
  GetRenderViewHost()->DragTargetDragLeave();
  if (delegate())
    delegate()->OnDragLeave();

  drop_data_.reset();
}

gboolean WebDragDestGtk::OnDragMotion(GtkWidget* sender,
                                      GdkDragContext* context,
                                      gint x, gint y,
                                      guint time) {
  if (context_ != context) {
    context_ = context;
    drop_data_.reset(new DropData);
    is_drop_target_ = false;

    if (delegate())
      delegate()->DragInitialize(web_contents_);

    // text/plain must come before text/uri-list. This is a hack that works in
    // conjunction with OnDragDataReceived. Since some file managers populate
    // text/plain with file URLs when dragging files, we want to handle
    // text/uri-list after text/plain so that the plain text can be cleared if
    // it's a file drag.
    static int supported_targets[] = {
      ui::TEXT_PLAIN,
      ui::TEXT_URI_LIST,
      ui::TEXT_HTML,
      ui::NETSCAPE_URL,
      ui::CHROME_NAMED_URL,
      // TODO(estade): support image drags?
      ui::CUSTOM_DATA,
    };

    // Add the delegate's requested target if applicable. Need to do this here
    // since gtk_drag_get_data will dispatch to our drag-data-received.
    data_requests_ = arraysize(supported_targets) + (delegate() ? 1 : 0);
    for (size_t i = 0; i < arraysize(supported_targets); ++i) {
      gtk_drag_get_data(widget_, context,
                        ui::GetAtomForTarget(supported_targets[i]),
                        time);
    }

    if (delegate()) {
      gtk_drag_get_data(widget_, context, delegate()->GetBookmarkTargetAtom(),
                        time);
    }
  } else if (data_requests_ == 0) {
    if (canceled_)
      return FALSE;

    GetRenderViewHost()->DragTargetDragOver(
        ui::ClientPoint(widget_),
        ui::ScreenPoint(widget_),
        GdkDragActionToWebDragOp(context->actions),
        GetModifierFlags(widget_));

    if (delegate())
      delegate()->OnDragOver();

    drag_over_time_ = time;
  }

  // Pretend we are a drag destination because we don't want to wait for
  // the renderer to tell us if we really are or not.
  return TRUE;
}

void WebDragDestGtk::OnDragDataReceived(
    GtkWidget* sender, GdkDragContext* context, gint x, gint y,
    GtkSelectionData* data, guint info, guint time) {
  // We might get the data from an old get_data() request that we no longer
  // care about.
  if (context != context_)
    return;

  data_requests_--;

  // Decode the data.
  gint data_length = gtk_selection_data_get_length(data);
  const guchar* raw_data = gtk_selection_data_get_data(data);
  GdkAtom target = gtk_selection_data_get_target(data);
  if (raw_data && data_length > 0) {
    // If the source can't provide us with valid data for a requested target,
    // raw_data will be NULL.
    if (target == ui::GetAtomForTarget(ui::TEXT_PLAIN)) {
      guchar* text = gtk_selection_data_get_text(data);
      if (text) {
        drop_data_->text = base::NullableString16(
            UTF8ToUTF16(std::string(reinterpret_cast<const char*>(text))),
            false);
        g_free(text);
      }
    } else if (target == ui::GetAtomForTarget(ui::TEXT_URI_LIST)) {
      gchar** uris = gtk_selection_data_get_uris(data);
      if (uris) {
        drop_data_->url = GURL();
        for (gchar** uri_iter = uris; *uri_iter; uri_iter++) {
          // Most file managers populate text/uri-list with file URLs when
          // dragging files. To avoid exposing file system paths to web content,
          // file URLs are never set as the URL content for the drop.
          // TODO(estade): Can the filenames have a non-UTF8 encoding?
          GURL url(*uri_iter);
          base::FilePath file_path;
          if (url.SchemeIs(chrome::kFileScheme) &&
              net::FileURLToFilePath(url, &file_path)) {
            drop_data_->filenames.push_back(
                DropData::FileInfo(UTF8ToUTF16(file_path.value()),
                                   base::string16()));
            // This is a hack. Some file managers also populate text/plain with
            // a file URL when dragging files, so we clear it to avoid exposing
            // it to the web content.
            drop_data_->text = base::NullableString16();
          } else if (!drop_data_->url.is_valid()) {
            // Also set the first non-file URL as the URL content for the drop.
            drop_data_->url = url;
          }
        }
        g_strfreev(uris);
      }
    } else if (target == ui::GetAtomForTarget(ui::TEXT_HTML)) {
      // TODO(estade): Can the html have a non-UTF8 encoding?
      drop_data_->html = base::NullableString16(
          UTF8ToUTF16(std::string(reinterpret_cast<const char*>(raw_data),
                                  data_length)),
          false);
      // We leave the base URL empty.
    } else if (target == ui::GetAtomForTarget(ui::NETSCAPE_URL)) {
      std::string netscape_url(reinterpret_cast<const char*>(raw_data),
                               data_length);
      size_t split = netscape_url.find_first_of('\n');
      if (split != std::string::npos) {
        drop_data_->url = GURL(netscape_url.substr(0, split));
        if (split < netscape_url.size() - 1)
          drop_data_->url_title = UTF8ToUTF16(netscape_url.substr(split + 1));
      }
    } else if (target == ui::GetAtomForTarget(ui::CHROME_NAMED_URL)) {
      ui::ExtractNamedURL(data, &drop_data_->url, &drop_data_->url_title);
    } else if (target == ui::GetAtomForTarget(ui::CUSTOM_DATA)) {
      ui::ReadCustomDataIntoMap(
          raw_data, data_length, &drop_data_->custom_data);
    }
  }

  if (data_requests_ == 0) {
    // Give the delegate an opportunity to cancel the drag.
    canceled_ = !web_contents_->GetDelegate()->CanDragEnter(
        web_contents_,
        *drop_data_,
        GdkDragActionToWebDragOp(context->actions));
    if (canceled_) {
      drag_over_time_ = time;
      UpdateDragStatus(WebDragOperationNone);
      drop_data_.reset();
      return;
    }
  }

  // For CHROME_BOOKMARK_ITEM, we have to handle the case where the drag source
  // doesn't have any data available for us. In this case we try to synthesize a
  // URL bookmark.
  // Note that bookmark drag data is encoded in the same format for both
  // GTK and Views, hence we can share the same logic here.
  if (delegate() && target == delegate()->GetBookmarkTargetAtom()) {
    if (raw_data && data_length > 0) {
      delegate()->OnReceiveDataFromGtk(data);
    } else {
      delegate()->OnReceiveProcessedData(drop_data_->url,
                                         drop_data_->url_title);
    }
  }

  if (data_requests_ == 0) {
    // Tell the renderer about the drag.
    // |x| and |y| are seemingly arbitrary at this point.
    GetRenderViewHost()->DragTargetDragEnter(
        *drop_data_.get(),
        ui::ClientPoint(widget_),
        ui::ScreenPoint(widget_),
        GdkDragActionToWebDragOp(context->actions),
        GetModifierFlags(widget_));

    if (delegate())
      delegate()->OnDragEnter();

    drag_over_time_ = time;
  }
}

// The drag has left our widget; forward this information to the renderer.
void WebDragDestGtk::OnDragLeave(GtkWidget* sender, GdkDragContext* context,
                                 guint time) {
  // Set |context_| to NULL to make sure we will recognize the next DragMotion
  // as an enter.
  context_ = NULL;

  if (canceled_)
    return;

  // Sometimes we get a drag-leave event before getting a drag-data-received
  // event. In that case, we don't want to bother the renderer with a
  // DragLeave event.
  if (data_requests_ != 0)
    return;

  // When GTK sends us a drag-drop signal, it is shortly (and synchronously)
  // preceded by a drag-leave. The renderer doesn't like getting the signals
  // in this order so delay telling it about the drag-leave till we are sure
  // we are not getting a drop as well.
  base::MessageLoop::current()->PostTask(
      FROM_HERE,
      base::Bind(&WebDragDestGtk::DragLeave, method_factory_.GetWeakPtr()));
}

// Called by GTK when the user releases the mouse, executing a drop.
gboolean WebDragDestGtk::OnDragDrop(GtkWidget* sender, GdkDragContext* context,
                                    gint x, gint y, guint time) {
  // Cancel that drag leave!
  method_factory_.InvalidateWeakPtrs();

  GetRenderViewHost()->
      DragTargetDrop(ui::ClientPoint(widget_), ui::ScreenPoint(widget_),
          GetModifierFlags(widget_));

  if (delegate())
    delegate()->OnDrop();

  // The second parameter is just an educated guess as to whether or not the
  // drag succeeded, but at least we will get the drag-end animation right
  // sometimes.
  gtk_drag_finish(context, is_drop_target_, FALSE, time);

  return TRUE;
}

RenderViewHostImpl* WebDragDestGtk::GetRenderViewHost() const {
  return static_cast<RenderViewHostImpl*>(web_contents_->GetRenderViewHost());
}

}  // namespace content