Browser tests for OOPIF support for drag-n-drop.

content/public/test/browser_test_utils.h

 // 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.
 
 #ifndef CONTENT_PUBLIC_TEST_BROWSER_TEST_UTILS_H_
 #define CONTENT_PUBLIC_TEST_BROWSER_TEST_UTILS_H_
 
 #include <queue>
 #include <string>
 #include <vector>
@@ skipping 174 matching lines @@
   RenderFrameHost* render_frame_host() const { return render_frame_host_; }
 
  private:
   RenderFrameHost* render_frame_host_;
 };
 
 RenderFrameHost* ConvertToRenderFrameHost(RenderViewHost* render_view_host);
 RenderFrameHost* ConvertToRenderFrameHost(RenderFrameHost* render_view_host);
 RenderFrameHost* ConvertToRenderFrameHost(WebContents* web_contents);
 
+class DOMAutomationWaiter : public NotificationObserver,

[ncarter (slow), 2016/11/01 19:50:52]

Can we do this as an enhancement to the existing DOMMessageQueue? They seem to
be offering equivalent functionality, with slightly different surfacing.

 - ctor that targets a particular WebContents (or RFH even) is a nice
enhancement.
 - The handling of crashes is a huge improvement.
 - As written, it's not possible to use DOMAutomationWaiter to obtain more than
one message (this matters in cases like this:
https://cs.chromium.org/chromium/src/content/browser/site_per_process_browser...
when you're waiting for two events that could arrive in either order.)
 - not clear how test-friendly base::Value is.

 - Maybe DOMMessageQueue could have a variant like this, which is how most
places use it in practice:

WaitForStringEqualing(std::string expected) {
  while (this->WaitForMessage(&message)) {
    if (message == "\"" + expected + "\"")
      return;
  }
}

[Łukasz Anforowicz, 2016/11/01 23:43:41]

Agreed that DOMAutomationWaiter can be scraped and replaced with
DOMMessageQueue.
I am not sure.  FWIW, I switched to using testing::HasSubstr and/or
base::MatchPattern (instead of parsing JSON).
DOMDragEventWaiter needs pattern matching (rather than straight-up equality) so
I didn't add anything like this just yet.

+                            public WebContentsObserver {
+ public:
+  // Starts monitoring the |target| for calls to
+  // window.domAutomationController.send(...).
+  explicit DOMAutomationWaiter(WebContents* target);
+
+  ~DOMAutomationWaiter() override;
+
+  // Waits until the window.domAutomationController.send(response) is called
+  // inside the |target| (the one that was passed to the constructor) and
+  // ShouldStopWaiting returns true for the |response| received from |target|.
+  //
+  // If |out_response| is not null, then it will receive the |response| from the
+  // |target|.  It is okay if |out_response| is null.
+  //
+  // Returns true if the expected response was received (and false if the wait
+  // was intrrupted for other reasons - e.g. if a renderer crashed).
+  bool WaitAndGetResponse(std::unique_ptr<base::Value>* out_response)
+      WARN_UNUSED_RESULT;
+
+ protected:
+  // Returns whether to stop waiting for the given |response| value (passed by
+  // javascript to window.domAutomationController.send).  In default
+  // implementation all |response| values stop waiting.
+  virtual bool ShouldStopWaiting(const base::Value& response);

[Łukasz Anforowicz, 2016/11/01 23:43:41]

Yesterday I read an article arguing for minimizing the number of member methods
in general (*) and I've started wondering whether the ShouldStopWaiting method
could be removed (and replaced by DOMDragEventWaiter in
drag_and_drop_browsertest.cc calling WaitAndGetResponse in a loop, until it gets
an expected response).

(*) http://www.gotw.ca/gotw/084.htm

+
+ private:
+  // WebContentsObserver overrides,

[ncarter (slow), 2016/11/01 19:50:52]

, -> .

[Łukasz Anforowicz, 2016/11/01 23:43:41]

Acknowledged.  (not applicable anymore after removal of DOMAutomationWaiter)

+  void RenderProcessGone(base::TerminationStatus status) override;
+
+  // NotificationObserver overrides.
+  void Observe(int type,
+               const NotificationSource& source,
+               const NotificationDetails& details) override;
+
+  std::unique_ptr<base::Value> response_;
+  scoped_refptr<MessageLoopRunner> message_loop_runner_;
+  NotificationRegistrar registrar_;
+
+  DISALLOW_COPY_AND_ASSIGN(DOMAutomationWaiter);
+};
+
 // Executes the passed |script| in the specified frame. The |script| should not
 // invoke domAutomationController.send(); otherwise, your test will hang or be
 // flaky. If you want to extract a result, use one of the below functions.
 // Returns true on success.
 bool ExecuteScript(const ToRenderFrameHost& adapter,
                    const std::string& script) WARN_UNUSED_RESULT;
 
 // The following methods executes the passed |script| in the specified frame and
 // sets |result| to the value passed to "window.domAutomationController.send" by
 // the executed script. They return true on success, false if the script
@@ skipping 491 matching lines @@
 
   // The MessageLoopRunner used to spin the message loop.
   scoped_refptr<MessageLoopRunner> message_loop_runner_;
 
   DISALLOW_COPY_AND_ASSIGN(ConsoleObserverDelegate);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_PUBLIC_TEST_BROWSER_TEST_UTILS_H_