Mac Support for drag-and-drop tests that start dragging via mouse simulation.

chrome/browser/ui/views/drag_and_drop_interactive_uitest.cc

 // Copyright 2016 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/ui/views/drag_and_drop_interactive_uitest.h"
+
 #include <algorithm>
 #include <initializer_list>
 #include <memory>
 #include <string>
 #include <vector>
 
 #include "base/callback.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/sequenced_task_runner.h"
 #include "base/strings/pattern.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/sequenced_task_runner_handle.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/test/base/in_process_browser_test.h"
 #include "chrome/test/base/interactive_test_utils.h"
 #include "chrome/test/base/ui_test_utils.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/web_contents.h"
+#include "content/public/common/drop_data.h"
 #include "content/public/test/browser_test_utils.h"
 #include "content/public/test/content_browser_test.h"
 #include "content/public/test/content_browser_test_utils.h"
 #include "content/public/test/test_frame_navigation_observer.h"
 #include "content/public/test/test_utils.h"
 #include "net/base/escape.h"
 #include "net/dns/mock_host_resolver.h"
 #include "net/test/embedded_test_server/embedded_test_server.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
-#include "ui/aura/client/drag_drop_client.h"
-#include "ui/aura/client/drag_drop_delegate.h"
-#include "ui/aura/client/screen_position_client.h"
-#include "ui/aura/window.h"
-#include "ui/base/dragdrop/drag_drop_types.h"
-#include "ui/base/dragdrop/drop_target_event.h"
-#include "ui/base/dragdrop/os_exchange_data.h"
 #include "ui/gfx/geometry/point.h"
 #include "ui/gfx/geometry/rect.h"
 #include "url/gurl.h"
 
 namespace chrome {
 
 namespace {
 
-// TODO(lukasza): Support testing on non-Aura platforms (i.e. Android + Mac?).
-//
-// Notes for the TODO above:
-//
-// - Why inject/simulate drag-and-drop events at the aura::Window* level.
-//
-//   - It seems better to inject into UI libraries to cover code *inside* these
-//     libraries.  This might complicate simulation a little bit (i.e. picking
-//     the right aura::Window and/or aura::client::DragDropDelegate to target),
-//     but otherwise important bits of code wouldn't get test coverage (i.e.
-//     directly injecting into RenderViewHost->DragTargetDragEnter seems wrong).
-//
-//   - In theory, we could introduce WebContentsImpl::DragTargetDragEnter (to be
-//     used by all UI platforms - so reused by web_contents_view_android.cc,
-//     web_contents_view_aura.cc, web_drag_dest_mac.mm), but it feels wrong - UI
-//     libraries should already know which widget is the target of the event and
-//     so should be able to talk directly to the right widget (i.e. WebContents
-//     should not be responsible for mapping coordinates to a widget - this is
-//     the job of the UI library).
-//
-// - Unknowns:
-//
-//   - Will this work for WebView and Plugin testing.
-
-// Test helper for simulating drag and drop happening in WebContents.
-class DragAndDropSimulator {
+// Helper for waiting until a drag-and-drop starts (e.g. in response to a
+// mouse-down + mouse-move simulated by the test).
+class DragStartWaiter {
  public:
-  explicit DragAndDropSimulator(content::WebContents* web_contents)
-      : web_contents_(web_contents) {}
-
-  // Simulates notification that |text| was dragged from outside of the browser,
-  // into the specified |location| inside |web_contents|.
-  // |location| is relative to |web_contents|.
-  // Returns true upon success.
-  bool SimulateDragEnter(gfx::Point location, const std::string& text) {
-    ui::OSExchangeData data;
-    data.SetString(base::UTF8ToUTF16(text));
-    return SimulateDragEnter(location, data);
+  // Starts globally monitoring for a start of a drag-and-drop that originates
+  // from web contents.
+  DragStartWaiter()
+      : message_loop_runner_(new content::MessageLoopRunner),
+        suppress_passing_of_start_drag_further_(false),
+        drag_started_(false) {
+    content::RegisterDragStartCallback(
+        base::Bind(&DragStartWaiter::StartDragAndDrop, base::Unretained(this)));
   }
 
-  // Simulates dropping of the drag-and-dropped item.
-  // SimulateDragEnter needs to be called first.
-  // Returns true upon success.
-  bool SimulateDrop(gfx::Point location) {
-    if (!active_drag_event_) {
-      ADD_FAILURE() << "Cannot drop a drag that hasn't started yet.";
-      return false;
-    }
-
-    aura::client::DragDropDelegate* delegate = GetDragDropDelegate();
-    if (!delegate)
-      return false;
-
-    gfx::Point event_location;
-    gfx::Point event_root_location;
-    CalculateEventLocations(location, &event_location, &event_root_location);
-    active_drag_event_->set_location(event_location);
-    active_drag_event_->set_root_location(event_root_location);
-
-    delegate->OnDragUpdated(*active_drag_event_);
-    delegate->OnPerformDrop(*active_drag_event_);
-    return true;
-  }
-
- private:
-  bool SimulateDragEnter(gfx::Point location, const ui::OSExchangeData& data) {
-    if (active_drag_event_) {
-      ADD_FAILURE() << "Cannot start a new drag when old one hasn't ended yet.";
-      return false;
-    }
-
-    aura::client::DragDropDelegate* delegate = GetDragDropDelegate();
-    if (!delegate)
-      return false;
-
-    gfx::Point event_location;
-    gfx::Point event_root_location;
-    CalculateEventLocations(location, &event_location, &event_root_location);
-    active_drag_event_.reset(new ui::DropTargetEvent(
-        data, event_location, event_root_location, kDefaultSourceOperations));
-
-    delegate->OnDragEntered(*active_drag_event_);
-    delegate->OnDragUpdated(*active_drag_event_);
-    return true;
-  }
-
-  aura::client::DragDropDelegate* GetDragDropDelegate() {
-    gfx::NativeView view = web_contents_->GetContentNativeView();
-    aura::client::DragDropDelegate* delegate =
-        aura::client::GetDragDropDelegate(view);
-    EXPECT_TRUE(delegate) << "Expecting WebContents to have DragDropDelegate";
-    return delegate;
-  }
-
-  void CalculateEventLocations(gfx::Point web_contents_relative_location,
-                               gfx::Point* out_event_location,
-                               gfx::Point* out_event_root_location) {
-    gfx::NativeView view = web_contents_->GetNativeView();
-
-    *out_event_location = web_contents_relative_location;
-
-    gfx::Point root_location = web_contents_relative_location;
-    aura::Window::ConvertPointToTarget(view, view->GetRootWindow(),
-                                       &root_location);
-    *out_event_root_location = root_location;
-  }
-
-  // These are ui::DropTargetEvent::source_operations_ being sent when manually
-  // trying out drag&drop of an image file from Nemo (Ubuntu's file explorer)
-  // into a content_shell.
-  static constexpr int kDefaultSourceOperations = ui::DragDropTypes::DRAG_MOVE |
-                                                  ui::DragDropTypes::DRAG_COPY |
-                                                  ui::DragDropTypes::DRAG_LINK;
-
-  content::WebContents* web_contents_;
-  std::unique_ptr<ui::DropTargetEvent> active_drag_event_;
-
-  DISALLOW_COPY_AND_ASSIGN(DragAndDropSimulator);
-};
-
-// Helper for waiting until a drag-and-drop starts (e.g. in response to a
-// mouse-down + mouse-move simulated by the test).
-class DragStartWaiter : public aura::client::DragDropClient {
- public:
-  // Starts monitoring |web_contents| for a start of a drag-and-drop.
-  explicit DragStartWaiter(content::WebContents* web_contents)
-      : web_contents_(web_contents),
-        message_loop_runner_(new content::MessageLoopRunner),
-        suppress_passing_of_start_drag_further_(false),
-        drag_started_(false) {
-    DCHECK(web_contents_);
-
-    // Intercept calls to the old DragDropClient.
-    gfx::NativeWindow root_window =
-        web_contents_->GetContentNativeView()->GetRootWindow();
-    old_client_ = aura::client::GetDragDropClient(root_window);
-    aura::client::SetDragDropClient(root_window, this);
-  }
-
-  ~DragStartWaiter() override {
-    // Restore the original DragDropClient.
-    gfx::NativeWindow root_window =
-        web_contents_->GetContentNativeView()->GetRootWindow();
-    aura::client::SetDragDropClient(root_window, old_client_);
+  ~DragStartWaiter() {
+    // Unregister our callback.
+    content::RegisterDragStartCallback(content::DragStartCallback());
   }
 
   // Waits until we almost report a drag-and-drop start to the OS.
   // At that point
   // 1) the callback from PostTaskWhenDragStarts will be posted.
   // 2) the drag-start request will be forwarded to the OS
   //    (unless SuppressPassingStartDragFurther method was called).
   //
   // Note that if SuppressPassingStartDragFurther was not called then
   // WaitUntilDragStart can take a long time to return (it returns only after
   // the OS decides that the drag-and-drop has ended).
   //
   // Before returning populates |text|, |html| and other parameters with data
   // that would have been passed to the OS).  If the caller is not interested in
   // this data, then the corresponding argument can be null.
-  void WaitUntilDragStart(std::string* text,
-                          std::string* html,
-                          int* operation,
-                          gfx::Point* location_inside_web_contents) {
+  void WaitUntilDragStart(content::DropData* drop_data,
+                          blink::WebDragOperationsMask* drag_operations_mask) {
     message_loop_runner_->Run();
 
     // message_loop_runner_->Quit is only called from StartDragAndDrop.
     DCHECK(drag_started_);
 
-    if (text)
-      *text = text_;
-    if (html)
-      *html = html_;
-    if (operation)
-      *operation = operation_;
-    if (location_inside_web_contents)
-      *location_inside_web_contents = location_inside_web_contents_;
+    if (drop_data)
+      *drop_data = drop_data_;
+    if (drag_operations_mask)
+      *drag_operations_mask = drag_operations_mask_;
   }
 
   void SuppressPassingStartDragFurther() {
     suppress_passing_of_start_drag_further_ = true;
   }
 
   void PostTaskWhenDragStarts(const base::Closure& callback) {
     callback_to_run_inside_drag_and_drop_message_loop_ = callback;
   }
 
-  // aura::client::DragDropClient overrides:
-  int StartDragAndDrop(const ui::OSExchangeData& data,
-                       aura::Window* root_window,
-                       aura::Window* source_window,
-                       const gfx::Point& screen_location,
-                       int operation,
-                       ui::DragDropTypes::DragEventSource source) override {
+  // Implementation of DragStartCallback passed to RegisterDragStartCallback.
+  bool StartDragAndDrop(const content::DropData& drop_data,
+                        blink::WebDragOperationsMask drag_operations_mask) {
     DCHECK(!drag_started_);
     if (!drag_started_) {
       drag_started_ = true;
+      drop_data_ = drop_data;
+      drag_operations_mask_ = drag_operations_mask;
       message_loop_runner_->Quit();
-
-      base::string16 text;
-      if (data.GetString(&text))
-        text_ = base::UTF16ToUTF8(text);
-      else
-        text_ = "<no text>";
-
-      GURL base_url;
-      base::string16 html;
-      if (data.GetHtml(&html, &base_url))
-        html_ = base::UTF16ToUTF8(html);
-      else
-        html_ = "<no html>";
-
-      gfx::Rect bounds =
-          web_contents_->GetContentNativeView()->GetBoundsInScreen();
-      location_inside_web_contents_ =
-          screen_location - gfx::Vector2d(bounds.x(), bounds.y());
-
-      operation_ = operation;
     }
 
     if (!callback_to_run_inside_drag_and_drop_message_loop_.is_null()) {
       base::SequencedTaskRunnerHandle::Get()->PostTask(
           FROM_HERE,
           std::move(callback_to_run_inside_drag_and_drop_message_loop_));
       callback_to_run_inside_drag_and_drop_message_loop_.Reset();
     }
 
-    if (suppress_passing_of_start_drag_further_)
-      return 0;
-
-    // Start a nested drag-and-drop loop (might not return for a long time).
-    return old_client_->StartDragAndDrop(data, root_window, source_window,
-                                         screen_location, operation, source);
+    return suppress_passing_of_start_drag_further_;
   }
 
-  void DragCancel() override {
-    ADD_FAILURE() << "Unexpected call to DragCancel";
-  }
-
-  bool IsDragDropInProgress() override { return drag_started_; }
-
  private:
-  content::WebContents* web_contents_;
   scoped_refptr<content::MessageLoopRunner> message_loop_runner_;
-  aura::client::DragDropClient* old_client_;
   base::Closure callback_to_run_inside_drag_and_drop_message_loop_;
   bool suppress_passing_of_start_drag_further_;
 
   // Data captured during the first intercepted StartDragAndDrop call.
   bool drag_started_;
-  std::string text_;
-  std::string html_;
-  int operation_;
-  gfx::Point location_inside_web_contents_;
+  content::DropData drop_data_;
+  blink::WebDragOperationsMask drag_operations_mask_;
 
   DISALLOW_COPY_AND_ASSIGN(DragStartWaiter);
 };
 
 // Helper for waiting for notifications from
 // content/test/data/drag_and_drop/event_monitoring.js
 class DOMDragEventWaiter {
  public:
   DOMDragEventWaiter(const std::string& event_type_to_wait_for,
                      const content::ToRenderFrameHost& target)
@@ skipping 204 matching lines @@
 
   struct CrossSiteDrag_TestState;
   void CrossSiteDrag_Step2(CrossSiteDrag_TestState*);
   void CrossSiteDrag_Step3(CrossSiteDrag_TestState*);
 
  protected:
   void SetUpOnMainThread() override {
     host_resolver()->AddRule("*", "127.0.0.1");
     content::SetupCrossSiteRedirector(embedded_test_server());
     ASSERT_TRUE(embedded_test_server()->Start());
-    drag_simulator_.reset(new DragAndDropSimulator(web_contents()));
+
+    ASSERT_TRUE(ui_test_utils::BringBrowserWindowToFront(browser()));
   }
 
   bool use_cross_site_subframe() {
     // This is controlled by gtest's test param from INSTANTIATE_TEST_CASE_P.
     return GetParam();
   }
 
   content::RenderFrameHost* left_frame() {
     AssertTestPageIsLoaded();
     return GetFrameByName("left");
@@ skipping 65 matching lines @@
     return true;
   }
 
   gfx::Point expected_location_of_drag_start_in_left_frame() {
     // TODO(crbug.com/653490): The delta below should exceed kDragThresholdX and
     // kDragThresholdY from MouseEventManager.cpp in blink.  Ideally, it would
     // come from the OS instead.
     return kMiddleOfLeftFrame + gfx::Vector2d(10, 10);
   }
 
+  gfx::Point middle_of_right_frame() { return kMiddleOfRightFrame; }
+
   bool SimulateMouseMoveToLeftFrame() {
     AssertTestPageIsLoaded();
     return SimulateMouseMove(kMiddleOfLeftFrame);
   }
 
   bool SimulateMouseMoveToRightFrame() {
     AssertTestPageIsLoaded();
     return SimulateMouseMove(kMiddleOfRightFrame);
   }
 
   bool SimulateMouseUp() {
     return ui_test_utils::SendMouseEventsSync(ui_controls::LEFT,
                                               ui_controls::UP);
   }
 
-  ////////////////////////////////////////////////////////////////////
-  // Simulation of dragging from outside the browser into web contents
-  // (using DragAndDropSimulator, not simulating mouse events).
-
-  bool SimulateDragEnterToRightFrame(const std::string& text) {
-    AssertTestPageIsLoaded();
-    return drag_simulator_->SimulateDragEnter(kMiddleOfRightFrame, text);
-  }
-
-  bool SimulateDropInRightFrame() {
-    AssertTestPageIsLoaded();
-    return drag_simulator_->SimulateDrop(kMiddleOfRightFrame);
-  }
-
  private:
   // Constants with coordinates within content/test/data/drag_and_drop/page.html
   // The precise frame center is at 200,200 and 400,200 coordinates, but slight
   // differences between left and right frame hopefully make it easier to detect
   // incorrect dom_drag_and_drop_event.clientX/Y values in test asserts.
   const gfx::Point kMiddleOfLeftFrame = gfx::Point(155, 150);
   const gfx::Point kMiddleOfRightFrame = gfx::Point(455, 250);
 
   bool SimulateMouseDown() {
     return ui_test_utils::SendMouseEventsSync(ui_controls::LEFT,
                                               ui_controls::DOWN);
   }
 
   bool SimulateMouseMove(const gfx::Point& location_inside_web_contents) {
     gfx::Rect bounds = web_contents()->GetContainerBounds();
-    return ui_test_utils::SendMouseMoveSync(
-        gfx::Point(bounds.x() + location_inside_web_contents.x(),
-                   bounds.y() + location_inside_web_contents.y()));
+    gfx::Point pos(bounds.x() + location_inside_web_contents.x(),
+                   bounds.y() + location_inside_web_contents.y());
+    LOG(ERROR) << "SimulateMouseMove"
+               << "; pos=(" << pos.x() << "," << pos.y() << ")";
+    return ui_test_utils::SendMouseMoveSync(pos);
   }
 
   bool NavigateNamedFrame(const std::string& frame_name,
                           const std::string& origin,
                           const std::string& filename) {
     content::RenderFrameHost* frame = GetFrameByName(frame_name);
     if (!frame)
       return false;
 
     std::string script;
@@ skipping 49 matching lines @@
 
     EXPECT_TRUE(result) << "Couldn't find a frame named "
                         << "'" << name_to_find << "'";
     return result;
   }
 
   void AssertTestPageIsLoaded() {
     ASSERT_EQ(kTestPagePath, web_contents()->GetLastCommittedURL().path());
   }
 
-  std::unique_ptr<DragAndDropSimulator> drag_simulator_;
-
   DISALLOW_COPY_AND_ASSIGN(DragAndDropBrowserTest);
 };
 
+// TODO(lukasza): Implement ExternalDragEnterSimulator for Mac.
+#if !defined(OS_MACOSX)
+
 // Scenario: drag text from outside the browser and drop to the right frame.
 // Test coverage: dragover, drop DOM events.
 IN_PROC_BROWSER_TEST_P(DragAndDropBrowserTest, DropTextFromOutside) {
+  std::unique_ptr<ExternalDragEnterSimulator> drag_simulator =
+      ExternalDragEnterSimulator::Create(web_contents());
+
   std::string frame_site = use_cross_site_subframe() ? "b.com" : "a.com";
   ASSERT_TRUE(NavigateToTestPage("a.com"));
   ASSERT_TRUE(NavigateRightFrame(frame_site, "drop_target.html"));
 
   // Setup test expectations.
   DOMDragEventVerifier expected_dom_event_data;
   expected_dom_event_data.set_expected_client_position("(155, 150)");
   expected_dom_event_data.set_expected_drop_effect("none");
   expected_dom_event_data.set_expected_effect_allowed("all");
   expected_dom_event_data.set_expected_mime_types("text/plain");
   expected_dom_event_data.set_expected_page_position("(155, 150)");
 
   // Drag text from outside the browser into/over the right frame.
   {
     DOMDragEventWaiter dragover_waiter("dragover", right_frame());
-    ASSERT_TRUE(SimulateDragEnterToRightFrame("Dragged test text"));
+    ASSERT_TRUE(drag_simulator->SimulateDragEnter(middle_of_right_frame(),
+                                                  "Dragged test text"));
 
     std::string dragover_event;
     ASSERT_TRUE(dragover_waiter.WaitForNextMatchingEvent(&dragover_event));
     EXPECT_THAT(dragover_event, expected_dom_event_data.Matches());
   }
 
   // Drop into the right frame.
   {
     DOMDragEventWaiter drop_waiter("drop", right_frame());
-    ASSERT_TRUE(SimulateDropInRightFrame());
+    ASSERT_TRUE(drag_simulator->SimulateDrop(middle_of_right_frame()));
 
     std::string drop_event;
     ASSERT_TRUE(drop_waiter.WaitForNextMatchingEvent(&drop_event));
     EXPECT_THAT(drop_event, expected_dom_event_data.Matches());
   }
 }
 
+#endif
+
 // Scenario: starting a drag in left frame
 // Test coverage: dragstart DOM event, dragstart data passed to the OS.
 IN_PROC_BROWSER_TEST_P(DragAndDropBrowserTest, DragStartInFrame) {
   std::string frame_site = use_cross_site_subframe() ? "b.com" : "a.com";
   ASSERT_TRUE(NavigateToTestPage("a.com"));
   ASSERT_TRUE(NavigateLeftFrame(frame_site, "image_source.html"));
 
   // Setup test expectations.
   DOMDragEventVerifier expected_dom_event_data;
   expected_dom_event_data.set_expected_client_position("(55, 50)");
   expected_dom_event_data.set_expected_drop_effect("none");
   // (dragstart event handler in image_source.html is asking for "copy" only).
   expected_dom_event_data.set_expected_effect_allowed("copy");
   expected_dom_event_data.set_expected_page_position("(55, 50)");
 
   // TODO(lukasza): Figure out why the dragstart event
   // - lists "Files" on the mime types list,
   // - doesn't list "text/plain" on the mime types list.
   // (i.e. why expectations below differ from expectations for dragenter,
   // dragover, dragend and/or drop events in DragImageBetweenFrames test).
   expected_dom_event_data.set_expected_mime_types(
       "Files,text/html,text/uri-list");
 
   // Start the drag in the left frame.
-  DragStartWaiter drag_start_waiter(web_contents());
+  DragStartWaiter drag_start_waiter;
   drag_start_waiter.SuppressPassingStartDragFurther();
   DOMDragEventWaiter dragstart_event_waiter("dragstart", left_frame());
   EXPECT_TRUE(SimulateMouseDownAndDragStartInLeftFrame());
 
   // Verify Javascript event data.
   {
     std::string dragstart_event;
     EXPECT_TRUE(
         dragstart_event_waiter.WaitForNextMatchingEvent(&dragstart_event));
     EXPECT_THAT(dragstart_event, expected_dom_event_data.Matches());
   }
 
   // Verify data being passed to the OS.
   {
-    std::string text;
-    std::string html;
-    int operation = 0;
-    gfx::Point location_inside_web_contents;
-    drag_start_waiter.WaitUntilDragStart(&text, &html, &operation,
-                                         &location_inside_web_contents);
+    content::DropData drop_data;
+    blink::WebDragOperationsMask operation;
+    drag_start_waiter.WaitUntilDragStart(&drop_data, &operation);
+
+    EXPECT_EQ("Alternative image text", base::UTF16ToUTF8(drop_data.url_title));
+    EXPECT_TRUE(drop_data.text.is_null());
+
+    EXPECT_EQ("droids.jpg",
+              base::UTF16ToUTF8(drop_data.file_description_filename));
     EXPECT_EQ(embedded_test_server()->GetURL(frame_site,
                                              "/image_decoding/droids.jpg"),
-              text);
-    EXPECT_THAT(html,
-                testing::MatchesRegex("<img .*src=\""
+              drop_data.url);
+
+    ASSERT_FALSE(drop_data.html.is_null());
+    EXPECT_THAT(base::UTF16ToUTF8(drop_data.html.string()),
+                testing::MatchesRegex("^<img .*src=\""
                                       "http://.*/image_decoding/droids.jpg"
-                                      "\">"));
-    EXPECT_EQ(expected_location_of_drag_start_in_left_frame(),
-              location_inside_web_contents);
-    EXPECT_EQ(ui::DragDropTypes::DRAG_COPY, operation);
+                                      "\".*$"));
+
+    EXPECT_THAT(drop_data.filenames, testing::IsEmpty());
+    EXPECT_THAT(drop_data.file_mime_types, testing::IsEmpty());
+
+    EXPECT_THAT(drop_data.custom_data, testing::IsEmpty());
+
+    EXPECT_EQ("", base::UTF16ToUTF8(drop_data.filesystem_id));
+    EXPECT_THAT(drop_data.file_system_files, testing::IsEmpty());
+
+    EXPECT_EQ(blink::WebDragOperationCopy, operation);
   }
 
   // Try to leave everything in a clean state.
   SimulateMouseUp();
 }
 
 // There is no known way to execute test-controlled tasks during
 // a drag-and-drop loop run by Windows OS.
 #if defined(OS_WIN)
 #define MAYBE_DragImageBetweenFrames DISABLED_DragImageBetweenFrames
@@ skipping 30 matching lines @@
       new DOMDragEventCounter(right_frame()));
   state.expected_dom_event_data.set_expected_client_position("(55, 50)");
   state.expected_dom_event_data.set_expected_drop_effect("none");
   // (dragstart event handler in image_source.html is asking for "copy" only).
   state.expected_dom_event_data.set_expected_effect_allowed("copy");
   state.expected_dom_event_data.set_expected_mime_types(
       "text/html,text/plain,text/uri-list");
   state.expected_dom_event_data.set_expected_page_position("(55, 50)");
 
   // Start the drag in the left frame.
-  DragStartWaiter drag_start_waiter(web_contents());
+  DragStartWaiter drag_start_waiter;
   drag_start_waiter.PostTaskWhenDragStarts(
       base::Bind(&DragAndDropBrowserTest::DragImageBetweenFrames_Step2,
                  base::Unretained(this), base::Unretained(&state)));
   state.dragstart_event_waiter.reset(
       new DOMDragEventWaiter("dragstart", left_frame()));
   EXPECT_TRUE(SimulateMouseDownAndDragStartInLeftFrame());
 
   // The next step of the test (DragImageBetweenFrames_Step2) runs inside the
   // nested drag-and-drop message loop - the call below won't return until the
   // drag-and-drop has already ended.
-  drag_start_waiter.WaitUntilDragStart(nullptr, nullptr, nullptr, nullptr);
+  drag_start_waiter.WaitUntilDragStart(nullptr, nullptr);
 
   DragImageBetweenFrames_Step3(&state);
 }
 
 void DragAndDropBrowserTest::DragImageBetweenFrames_Step2(
     DragAndDropBrowserTest::DragImageBetweenFrames_TestState* state) {
   // Verify dragstart DOM event.
   {
     std::string dragstart_event;
     EXPECT_TRUE(state->dragstart_event_waiter->WaitForNextMatchingEvent(
@@ skipping 179 matching lines @@
   ASSERT_TRUE(NavigateLeftFrame(left_frame_site, "image_source.html"));
   ASSERT_TRUE(NavigateRightFrame(right_frame_site, "drop_target.html"));
 
   // Setup test expectations.
   DragAndDropBrowserTest::CrossSiteDrag_TestState state;
   state.left_frame_events_counter.reset(new DOMDragEventCounter(left_frame()));
   state.right_frame_events_counter.reset(
       new DOMDragEventCounter(right_frame()));
 
   // Start the drag in the left frame.
-  DragStartWaiter drag_start_waiter(web_contents());
+  DragStartWaiter drag_start_waiter;
   drag_start_waiter.PostTaskWhenDragStarts(
       base::Bind(&DragAndDropBrowserTest::CrossSiteDrag_Step2,
                  base::Unretained(this), base::Unretained(&state)));
   EXPECT_TRUE(SimulateMouseDownAndDragStartInLeftFrame());
 
   // The next step of the test (CrossSiteDrag_Step2) runs inside the
   // nested drag-and-drop message loop - the call below won't return until the
   // drag-and-drop has already ended.
-  drag_start_waiter.WaitUntilDragStart(nullptr, nullptr, nullptr, nullptr);
+  drag_start_waiter.WaitUntilDragStart(nullptr, nullptr);
 
   CrossSiteDrag_Step3(&state);
 }
 
 void DragAndDropBrowserTest::CrossSiteDrag_Step2(
     DragAndDropBrowserTest::CrossSiteDrag_TestState* state) {
   // While "dragleave" and "drop" events are not expected in this test, we
   // simulate extra mouse operations for consistency with
   // DragImageBetweenFrames_Step2.
   ASSERT_TRUE(SimulateMouseMoveToLeftFrame());
@@ skipping 54 matching lines @@
 // of a drag operation, and cross-site drags should be allowed across a
 // navigation.
 
 INSTANTIATE_TEST_CASE_P(
     SameSiteSubframe, DragAndDropBrowserTest, ::testing::Values(false));
 
 INSTANTIATE_TEST_CASE_P(
     CrossSiteSubframe, DragAndDropBrowserTest, ::testing::Values(true));
 
 }  // namespace chrome