Allow dragging and dropping of URLs to any portion of the toolbar view....

chrome/browser/autocomplete/autocomplete_edit_view_win.cc

 // Copyright (c) 2011 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 "chrome/browser/autocomplete/autocomplete_edit_view_win.h"
 
 #include <algorithm>
 #include <locale>
 #include <string>
 
@@ skipping 22 matching lines @@
 #include "chrome/browser/search_engines/template_url_model.h"
 #include "chrome/browser/tab_contents/tab_contents.h"
 #include "chrome/browser/ui/views/location_bar/location_bar_view.h"
 #include "chrome/common/notification_service.h"
 #include "googleurl/src/url_util.h"
 #include "grit/generated_resources.h"
 #include "net/base/escape.h"
 #include "skia/ext/skia_utils_win.h"
 #include "ui/base/clipboard/clipboard.h"
 #include "ui/base/clipboard/scoped_clipboard_writer.h"
+#include "ui/base/dragdrop/drag_drop_types.h"
 #include "ui/base/dragdrop/drag_source.h"
 #include "ui/base/dragdrop/drop_target.h"
 #include "ui/base/dragdrop/os_exchange_data.h"
 #include "ui/base/dragdrop/os_exchange_data_provider_win.h"
 #include "ui/base/keycodes/keyboard_codes.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/l10n/l10n_util_win.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/canvas_skia.h"
 #include "views/controls/textfield/native_textfield_win.h"
 #include "views/drag_utils.h"
 #include "views/events/event_utils_win.h"
 #include "views/focus/focus_util_win.h"
 #include "views/widget/widget.h"
 
 #pragma comment(lib, "oleacc.lib")  // Needed for accessibility support.
 #pragma comment(lib, "riched20.lib")  // Needed for the richedit control.
 
 ///////////////////////////////////////////////////////////////////////////////
 // AutocompleteEditModel
 
 namespace {
 
+// A helper method for determining a valid DROPEFFECT given the allowed
+// DROPEFFECTS.  We prefer copy over link.
+DWORD CopyOrLinkDropEffect(DWORD effect) {
+  if (effect & DROPEFFECT_COPY)
+    return DROPEFFECT_COPY;
+  if (effect & DROPEFFECT_LINK)
+    return DROPEFFECT_LINK;
+  return DROPEFFECT_NONE;
+}
+
+// A helper method for determining a valid drag operation given the allowed
+// operation.  We prefer copy over link.
+int CopyOrLinkDragOperation(int drag_operation) {
+  if (drag_operation & ui::DragDropTypes::DRAG_COPY)
+    return ui::DragDropTypes::DRAG_COPY;
+  if (drag_operation & ui::DragDropTypes::DRAG_LINK)
+    return ui::DragDropTypes::DRAG_LINK;
+  return ui::DragDropTypes::DRAG_NONE;
+}
+
+// The AutocompleteEditState struct contains enough information about the
+// AutocompleteEditModel and AutocompleteEditViewWin to save/restore a user's
+// typing, caret position, etc. across tab changes.  We explicitly don't
+// preserve things like whether the popup was open as this might be weird.
+struct AutocompleteEditState {
+  AutocompleteEditState(const AutocompleteEditModel::State model_state,
+                        const AutocompleteEditViewWin::State view_state)
+      : model_state(model_state),
+        view_state(view_state) {
+  }
+
+  const AutocompleteEditModel::State model_state;
+  const AutocompleteEditViewWin::State view_state;
+};
+
+// Returns true if the current point is far enough from the origin that it
+// would be considered a drag.
+bool IsDrag(const POINT& origin, const POINT& current) {
+  return views::View::ExceededDragThreshold(current.x - origin.x,
+                                            current.y - origin.y);
+}
+
+}  // namespace
+
 // EditDropTarget is the IDropTarget implementation installed on
 // AutocompleteEditViewWin. EditDropTarget prefers URL over plain text. A drop
 // of a URL replaces all the text of the edit and navigates immediately to the
 // URL. A drop of plain text from the same edit either copies or moves the
 // selected text, and a drop of plain text from a source other than the edit
 // does a paste and go.
-class EditDropTarget : public ui::DropTarget {
+class AutocompleteEditViewWin::EditDropTarget : public ui::DropTarget {
  public:
   explicit EditDropTarget(AutocompleteEditViewWin* edit);
 
  protected:
   virtual DWORD OnDragEnter(IDataObject* data_object,
                             DWORD key_state,
                             POINT cursor_position,
                             DWORD effect);
   virtual DWORD OnDragOver(IDataObject* data_object,
                            DWORD key_state,
@@ skipping 19 matching lines @@
   // If true, the drag session contains a URL.
   bool drag_has_url_;
 
   // If true, the drag session contains a string. If drag_has_url_ is true,
   // this is false regardless of whether the clipboard has a string.
   bool drag_has_string_;
 
   DISALLOW_COPY_AND_ASSIGN(EditDropTarget);
 };
 
-// A helper method for determining a valid DROPEFFECT given the allowed
-// DROPEFFECTS.  We prefer copy over link.
-DWORD CopyOrLinkDropEffect(DWORD effect) {
-  if (effect & DROPEFFECT_COPY)
-    return DROPEFFECT_COPY;
-  if (effect & DROPEFFECT_LINK)
-    return DROPEFFECT_LINK;
-  return DROPEFFECT_NONE;
-}
-
-EditDropTarget::EditDropTarget(AutocompleteEditViewWin* edit)
+AutocompleteEditViewWin::EditDropTarget::EditDropTarget(
+    AutocompleteEditViewWin* edit)
     : ui::DropTarget(edit->m_hWnd),
       edit_(edit),
       drag_has_url_(false),
       drag_has_string_(false) {
 }
 
-DWORD EditDropTarget::OnDragEnter(IDataObject* data_object,
-                                  DWORD key_state,
-                                  POINT cursor_position,
-                                  DWORD effect) {
+DWORD AutocompleteEditViewWin::EditDropTarget::OnDragEnter(
+    IDataObject* data_object,
+    DWORD key_state,
+    POINT cursor_position,
+    DWORD effect) {
   ui::OSExchangeData os_data(new ui::OSExchangeDataProviderWin(data_object));
   drag_has_url_ = os_data.HasURL();
   drag_has_string_ = !drag_has_url_ && os_data.HasString();
   if (drag_has_url_) {
     if (edit_->in_drag()) {
       // The edit we're associated with originated the drag. No point in
       // allowing the user to drop back on us.
       drag_has_url_ = false;
     }
     // NOTE: it would be nice to visually show all the text is going to
     // be replaced by selecting all, but this caused painting problems. In
     // particular the flashing caret would appear outside the edit! For now
     // we stick with no visual indicator other than that shown own the mouse
     // cursor.
   }
   return OnDragOver(data_object, key_state, cursor_position, effect);
 }
 
-DWORD EditDropTarget::OnDragOver(IDataObject* data_object,
-                                 DWORD key_state,
-                                 POINT cursor_position,
-                                 DWORD effect) {
+DWORD AutocompleteEditViewWin::EditDropTarget::OnDragOver(
+    IDataObject* data_object,
+    DWORD key_state,
+    POINT cursor_position,
+    DWORD effect) {
   if (drag_has_url_)
     return CopyOrLinkDropEffect(effect);
 
   if (drag_has_string_) {
     UpdateDropHighlightPosition(cursor_position);
     if (edit_->drop_highlight_position() == -1 && edit_->in_drag())
       return DROPEFFECT_NONE;
     if (edit_->in_drag()) {
       // The edit we're associated with originated the drag.  Do the normal drag
       // behavior.
       DCHECK((effect & DROPEFFECT_COPY) && (effect & DROPEFFECT_MOVE));
       return (key_state & MK_CONTROL) ? DROPEFFECT_COPY : DROPEFFECT_MOVE;
     }
     // Our edit didn't originate the drag, only allow link or copy.
     return CopyOrLinkDropEffect(effect);
   }
 
   return DROPEFFECT_NONE;
 }
 
-void EditDropTarget::OnDragLeave(IDataObject* data_object) {
+void AutocompleteEditViewWin::EditDropTarget::OnDragLeave(
+    IDataObject* data_object) {
   ResetDropHighlights();
 }
 
-DWORD EditDropTarget::OnDrop(IDataObject* data_object,
-                             DWORD key_state,
-                             POINT cursor_position,
-                             DWORD effect) {
+DWORD AutocompleteEditViewWin::EditDropTarget::OnDrop(
+    IDataObject* data_object,
+    DWORD key_state,
+    POINT cursor_position,
+    DWORD effect) {
+  effect = OnDragOver(data_object, key_state, cursor_position, effect);
+
   ui::OSExchangeData os_data(new ui::OSExchangeDataProviderWin(data_object));
+  views::DropTargetEvent event(os_data, cursor_position.x, cursor_position.y,
+      ui::DragDropTypes::DropEffectToDragOperation(effect));
 
-  if (drag_has_url_) {
-    GURL url;
-    string16 title;
-    if (os_data.GetURLAndTitle(&url, &title)) {
-      edit_->SetUserText(UTF8ToWide(url.spec()));
-      edit_->model()->AcceptInput(CURRENT_TAB, true);
-      return CopyOrLinkDropEffect(effect);
-    }
-  } else if (drag_has_string_) {
-    int string_drop_position = edit_->drop_highlight_position();
-    string16 text;
-    if ((string_drop_position != -1 || !edit_->in_drag()) &&
-        os_data.GetString(&text)) {
-      DCHECK(string_drop_position == -1 ||
-             ((string_drop_position >= 0) &&
-              (string_drop_position <= edit_->GetTextLength())));
-      const DWORD drop_operation =
-          OnDragOver(data_object, key_state, cursor_position, effect);
-      if (edit_->in_drag()) {
-        if (drop_operation == DROPEFFECT_MOVE)
-          edit_->MoveSelectedText(string_drop_position);
-        else
-          edit_->InsertText(string_drop_position, text);
-      } else {
-        edit_->PasteAndGo(CollapseWhitespace(text, true));
-      }
-      ResetDropHighlights();
-      return drop_operation;
-    }
-  }
+  int drag_operation = edit_->OnPerformDropImpl(event, edit_->in_drag());
 
-  ResetDropHighlights();
+  if (!drag_has_url_)
+    ResetDropHighlights();
 
-  return DROPEFFECT_NONE;
+  return ui::DragDropTypes::DragOperationToDropEffect(drag_operation);
 }
 
-void EditDropTarget::UpdateDropHighlightPosition(
+void AutocompleteEditViewWin::EditDropTarget::UpdateDropHighlightPosition(
     const POINT& cursor_screen_position) {
   if (drag_has_string_) {
     POINT client_position = cursor_screen_position;
-    ScreenToClient(edit_->m_hWnd, &client_position);
+    ::ScreenToClient(edit_->m_hWnd, &client_position);
     int drop_position = edit_->CharFromPos(client_position);
     if (edit_->in_drag()) {
       // Our edit originated the drag, don't allow a drop if over the selected
       // region.
       LONG sel_start, sel_end;
       edit_->GetSel(sel_start, sel_end);
       if ((sel_start != sel_end) && (drop_position >= sel_start) &&
           (drop_position <= sel_end))
         drop_position = -1;
     } else {
       // A drop from a source other than the edit replaces all the text, so
       // we don't show the drop location. See comment in OnDragEnter as to why
       // we don't try and select all here.
       drop_position = -1;
     }
     edit_->SetDropHighlightPosition(drop_position);
   }
 }
 
-void EditDropTarget::ResetDropHighlights() {
+void AutocompleteEditViewWin::EditDropTarget::ResetDropHighlights() {
   if (drag_has_string_)
     edit_->SetDropHighlightPosition(-1);
 }
 
-// The AutocompleteEditState struct contains enough information about the
-// AutocompleteEditModel and AutocompleteEditViewWin to save/restore a user's
-// typing, caret position, etc. across tab changes.  We explicitly don't
-// preserve things like whether the popup was open as this might be weird.
-struct AutocompleteEditState {
-  AutocompleteEditState(const AutocompleteEditModel::State model_state,
-                        const AutocompleteEditViewWin::State view_state)
-      : model_state(model_state),
-        view_state(view_state) {
-  }
-
-  const AutocompleteEditModel::State model_state;
-  const AutocompleteEditViewWin::State view_state;
-};
-
-// Returns true if the current point is far enough from the origin that it
-// would be considered a drag.
-bool IsDrag(const POINT& origin, const POINT& current) {
-  // The CXDRAG and CYDRAG system metrics describe the width and height of a
-  // rectangle around the origin position, inside of which motion is not
-  // considered a drag.
-  return (abs(current.x - origin.x) > (GetSystemMetrics(SM_CXDRAG) / 2)) ||
-         (abs(current.y - origin.y) > (GetSystemMetrics(SM_CYDRAG) / 2));
-}
-
-}  // namespace
 
 ///////////////////////////////////////////////////////////////////////////////
 // Helper classes
 
 AutocompleteEditViewWin::ScopedFreeze::ScopedFreeze(
     AutocompleteEditViewWin* edit,
     ITextDocument* text_object_model)
     : edit_(edit),
       text_object_model_(text_object_model) {
   // Freeze the screen.
@@ skipping 670 matching lines @@
 }
 
 views::View* AutocompleteEditViewWin::AddToView(views::View* parent) {
   views::NativeViewHost* host = new views::NativeViewHost;
   parent->AddChildView(host);
   host->set_focus_view(parent);
   host->Attach(GetNativeView());
   return host;
 }
 
+int AutocompleteEditViewWin::OnPerformDrop(
+    const views::DropTargetEvent& event) {
+  return OnPerformDropImpl(event, false);
+}
+
+int AutocompleteEditViewWin::OnPerformDropImpl(
+    const views::DropTargetEvent& event,
+    bool in_drag) {
+  const ui::OSExchangeData& data = event.data();
+
+  if (data.HasURL()) {
+    GURL url;
+    string16 title;
+    if (data.GetURLAndTitle(&url, &title)) {
+      SetUserText(UTF8ToWide(url.spec()));
+      model()->AcceptInput(CURRENT_TAB, true);
+      return CopyOrLinkDragOperation(event.source_operations());
+    }
+  } else if (data.HasString()) {
+    int string_drop_position = drop_highlight_position();
+    string16 text;
+    if ((string_drop_position != -1 || !in_drag) && data.GetString(&text)) {
+      DCHECK(string_drop_position == -1 ||
+             ((string_drop_position >= 0) &&
+              (string_drop_position <= GetTextLength())));
+      if (in_drag) {
+        if (event.source_operations()== ui::DragDropTypes::DRAG_MOVE)
+          MoveSelectedText(string_drop_position);
+        else
+          InsertText(string_drop_position, text);
+      } else {
+        PasteAndGo(CollapseWhitespace(text, true));
+      }
+      return CopyOrLinkDragOperation(event.source_operations());
+    }
+  }
+
+  return ui::DragDropTypes::DRAG_NONE;
+}
+
 void AutocompleteEditViewWin::PasteAndGo(const string16& text) {
   if (CanPasteAndGo(text))
     model_->PasteAndGo();
 }
 
 bool AutocompleteEditViewWin::SkipDefaultKeyEventProcessing(
     const views::KeyEvent& e) {
   ui::KeyboardCode key = e.key_code();
   // We don't process ALT + numpad digit as accelerators, they are used for
   // entering special characters.  We do translate alt-home.
@@ skipping 1607 matching lines @@
   // PosFromChar(i) might return 0 when i is greater than 1.
   return font_.GetStringWidth(text) + GetHorizontalMargin();
 }
 
 bool AutocompleteEditViewWin::IsCaretAtEnd() const {
   long length = GetTextLength();
   CHARRANGE sel;
   GetSelection(sel);
   return sel.cpMin == sel.cpMax && sel.cpMin == length;
 }