ABANDONED CL: Some stuff to help with manual testing of drag-and-drop.

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 <memory>
 #include <string>
 
 #include "base/callback.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
@@ skipping 20 matching lines @@
 #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/base/test/ui_controls.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?).
 //
@@ skipping 325 matching lines @@
 };
 
 const char kTestPagePath[] = "/drag_and_drop/page.html";
 
 }  // namespace
 
 class DragAndDropBrowserTest : public InProcessBrowserTest {
  public:
   DragAndDropBrowserTest(){};
 
+  // Declarations of test continuations.
+  void DragImageToOtherFrame_Step2(const std::string& frame_site,
+                              const std::string& text,
+                              const std::string& html,
+                              int operation,
+                              bool did_originate_from_renderer);
+
  protected:
   void SetUpOnMainThread() override {
     host_resolver()->AddRule("*", "127.0.0.1");
     ASSERT_TRUE(embedded_test_server()->Start());
     content::SetupCrossSiteRedirector(embedded_test_server());
     drag_simulator_.reset(new DragAndDropSimulator(web_contents()));
   }
 
   content::RenderFrameHost* left_frame() {
     AssertTestPageIsLoaded();
@@ skipping 68 matching lines @@
     return drag_simulator_->SimulateDragEnter(kMiddleOfRightFrame, text);
   }
 
   bool SimulateDropInRightFrame() {
     AssertTestPageIsLoaded();
     return drag_simulator_->SimulateDrop(kMiddleOfRightFrame);
   }
 
  private:
   bool SimulateMouseDown() {
-    return ui_test_utils::SendMouseEventsSync(ui_controls::LEFT,
-                                              ui_controls::DOWN);
+    return ui_controls::SendMouseEvents(ui_controls::LEFT, ui_controls::DOWN);
+  }
+
+  gfx::Point GetScreenCoordinates(
+      const gfx::Point& location_inside_web_contents) {
+    gfx::Rect bounds = web_contents()->GetContainerBounds();
+    return gfx::Point(bounds.x() + location_inside_web_contents.x(),
+                      bounds.y() + location_inside_web_contents.y());
   }
 
   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()));
+        GetScreenCoordinates(location_inside_web_contents));
+  }
+
+  bool SimulateMouseMoveNotifyWhenDone(
+      const gfx::Point& location_inside_web_contents,
+      const base::Closure& done_callback) {
+    gfx::Point screen_location = GetScreenCoordinates(location_inside_web_contents);
+    return ui_controls::SendMouseMoveNotifyWhenDone(
+        screen_location.x(), screen_location.y(), done_callback);
   }
 
   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 89 matching lines @@
   {
     DOMDragEventWaiter drop_waiter("drop", right_frame());
     ASSERT_TRUE(SimulateDropInRightFrame());
 
     std::string drop_event;
     ASSERT_TRUE(drop_waiter.WaitForNextMatchingEvent(&drop_event));
     EXPECT_THAT(drop_event, expected_dom_event_data.Matches());
   }
 }
 
-// The test is disabled on Ozone because of trouble with mouse simulation
-// during the test - see https://crbug.com/665042.
-#if defined(USE_OZONE)
-#define MAYBE_DragStartInFrame DISABLED_DragStartInFrame
-#else
-#define MAYBE_DragStartInFrame DragStartInFrame
-#endif
+struct DragImageToOtherFrame_TestState {
+  std::string frame_site;
+
+  std::string expected_text;
+  std::string expected_html_regex;
+  int expected_operation;
+
+  std::string expected_drop_effect;
+  std::string expected_effect_allowed;
+  std::string expected_mime_types;
+
+  std::unique_ptr<DOMDragEventWaiter> dragend_event_waiter;
+};
+
+testing::Matcher<std::string> MatchesTestExpectations(
+    const DragImageToOtherFrame_TestState& test) {
+  auto matches_expected_drop_effect = testing::HasSubstr(base::StringPrintf(
+      "\"drop_effect\":\"%s\"", test.expected_drop_effect.c_str()));
+
+  auto matches_expected_effect_allowed = testing::HasSubstr(base::StringPrintf(
+      "\"effect_allowed\":\"%s\"", test.expected_effect_allowed.c_str()));
+
+  auto matches_expected_mime_types = testing::HasSubstr(base::StringPrintf(
+      "\"mime_types\":\"%s\"", test.expected_mime_types.c_str()));
+
+  return testing::AllOf(matches_expected_drop_effect,
+                        matches_expected_mime_types);
+}
+
 IN_PROC_BROWSER_TEST_F(DragAndDropBrowserTest, MAYBE_DragStartInFrame) {
   std::string frame_site = "b.com";
   ASSERT_TRUE(NavigateToTestPage("a.com"));
+
+  // Drag-and-drop is not allowed between cross-origin frames in the same page
+  // (see https://crbug.com/59081) - this is why left and right frame have to
+  // come from the same origin below.
   ASSERT_TRUE(NavigateLeftFrame(frame_site, "image_source.html"));
+  ASSERT_TRUE(NavigateRightFrame(frame_site, "drop_target.html"));
 
-  // Setup test expectations.
-  // (dragstart event handler in image_source.html is asking for "copy" only).
-  DOMDragEventVerifier expected_dom_event_data;
-  expected_dom_event_data.set_expected_drop_effect("none");
-  expected_dom_event_data.set_expected_effect_allowed("copy");
-  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());
-  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.WaitUntilDragStartIsIntercepted(
-        &text, &html, &operation, &location_inside_web_contents);
-    EXPECT_EQ(embedded_test_server()->GetURL(frame_site,
-                                             "/image_decoding/droids.jpg"),
-              text);
-    EXPECT_THAT(html,
-                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);
-  }
-
-  // Try to leave everything in a clean state.
-  SimulateMouseUp();
+  LOG(ERROR) << "Starting message loop for interactive UI...";
+  (new content::MessageLoopRunner)->Run();
 }
 
 }  // namespace chrome