headless: Initial headless embedder API implementation

headless/lib/headless_web_contents_browsertest.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 "base/run_loop.h"
+#include "content/public/test/browser_test.h"
+#include "headless/public/headless_browser.h"
+#include "headless/public/headless_web_contents.h"
+#include "headless/test/headless_browser_test.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "ui/gfx/geometry/size.h"
+#include "url/gurl.h"
+
+namespace headless {
+
+class HeadlessWebContentsTest : public HeadlessBrowserTest {};
+
+class WaitForNavigationObserver : public HeadlessWebContents::Observer {
+ public:
+  WaitForNavigationObserver(base::RunLoop* run_loop,
+                            HeadlessWebContents* web_contents)
+      : run_loop_(run_loop), web_contents_(web_contents) {
+    web_contents_->AddObserver(this);
+  }
+
+  ~WaitForNavigationObserver() override { web_contents_->RemoveObserver(this); }
+
+  void DocumentOnLoadCompletedInMainFrame() override { run_loop_->Quit(); }
+
+ private:
+  base::RunLoop* run_loop_;            // Not owned.
+  HeadlessWebContents* web_contents_;  // Not owned.
+
+  DISALLOW_COPY_AND_ASSIGN(WaitForNavigationObserver);
+};
+
+IN_PROC_BROWSER_TEST_F(HeadlessWebContentsTest, Navigation) {
+  EXPECT_TRUE(embedded_test_server()->Start());
+  scoped_ptr<HeadlessWebContents> web_contents =
+      browser()->CreateWebContents(gfx::Size(800, 600));
+
+  base::RunLoop run_loop;
+  base::MessageLoop::ScopedNestableTaskAllower nestable_allower(
+      base::MessageLoop::current());

[Ryan Sleevi, 2016/02/25 22:04:36]

o_O

ScopedNestableTasks are generally anathema - is this really needed? If so, why?
This is the kind of thing that definitely benefits from clear documentation,
since ideally we should
1) Never introduce new ones
2) Remove all existing

(OK, 2 is a bit of a pipe dream, since there are some special cases where it's
needed; but many can be refactored away)

[Sami, 2016/02/26 18:49:16]

Completely agreed about nested run loops -- they've caused nothing but strife in
our scheduler work. The fundamental problem here is that:

1. gtests have to complete synchronously, so some kind of explicit run loop must
be used if we want to wait for posted tasks to complete.
2. content/ requires a message loop in order to bring up the headless browser,
so by the time we end up here we can't create another one on the same thread.

Because of this the only way to wait for code that posts tasks to complete here
is to use a nested run loop. All of the existing browser tests have the same
basic flaw.

I think the only rational way to fix this is to teach gtest (and the rest of
Chromium) about std::future or some similar promise concept so that no-one ever
needs to deal with a message loop anymore.

+  WaitForNavigationObserver observer(&run_loop, web_contents.get());
+
+  web_contents->OpenURL(embedded_test_server()->GetURL("/hello.html"));
+  run_loop.Run();
+}
+
+IN_PROC_BROWSER_TEST_F(HeadlessWebContentsTest, NavigationWithBadURL) {
+  scoped_ptr<HeadlessWebContents> web_contents =
+      browser()->CreateWebContents(gfx::Size(800, 600));
+  GURL bad_url("not_valid");
+  EXPECT_FALSE(web_contents->OpenURL(bad_url));
+}
+
+}  // namespace headless