Headless render tests.

Test redirects with PUT.
Test redirect URL edgecases.

Bug: chromium:787197
Change-Id: I663516828741282f3a6364d71a4fc822a3814045
Reviewed-on: https://chromium-review.googlesource.com/804713
Commit-Queue: Sergei Datsenko <dats@chromium.org>
Reviewed-by: Alex Clarke <alexclarke@chromium.org>
Cr-Commit-Position: refs/heads/master@{#521910}

headless/public/util/testing/test_in_memory_protocol_handler.cc

@@ -21,14 +21,18 @@ class TestInMemoryProtocolHandler::MockURLFetcher : public URLFetcher {
   void StartFetch(const Request* request,
                   ResultListener* result_listener) override {
     GURL url = request->GetURLRequest()->url();
-    if (request->GetURLRequest()->method() == "POST") {
+    const std::string& method = request->GetURLRequest()->method();
+    if (method == "POST" || method == "PUT") {
       request->GetPostData();
+    } else if (method == "GET") {
+      // Do nothing.
     } else {
-      DCHECK_EQ("GET", request->GetURLRequest()->method());
+      DCHECK(false) << "Method " << method << " is not supported. Probably.";
     }
 
     std::string devtools_frame_id = request->GetDevToolsFrameId();
     DCHECK_NE(devtools_frame_id, "") << " For url " << url;
+    protocol_handler_->methods_requested_.push_back(method);
     protocol_handler_->RegisterUrl(url.spec(), devtools_frame_id);
 
     if (protocol_handler_->request_deferrer()) {

headless/public/util/testing/test_in_memory_protocol_handler.h

@@ -65,6 +65,10 @@ class TestInMemoryProtocolHandler
     return urls_requested_;
   }
 
+  const std::vector<std::string>& methods_requested() const {
+    return methods_requested_;
+  }
+
  private:
   const Response* GetResponse(const std::string& url) const;
 
@@ -86,6 +90,7 @@ class TestInMemoryProtocolHandler
   HeadlessBrowserContext* headless_browser_context_;
   std::map<std::string, std::string> url_to_devtools_frame_id_;
   std::vector<std::string> urls_requested_;
+  std::vector<std::string> methods_requested_;
   RequestDeferrer* request_deferrer_;  // NOT OWNED.
   scoped_refptr<base::SingleThreadTaskRunner> io_thread_task_runner_;
 

headless/test/headless_render_test.cc

@@ -38,6 +38,8 @@ void HeadlessRenderTest::RunDevTooledTest() {
 
   devtools_client_->GetPage()->GetExperimental()->AddObserver(this);
   devtools_client_->GetPage()->Enable(Sync());
+  devtools_client_->GetRuntime()->GetExperimental()->AddObserver(this);
+  devtools_client_->GetRuntime()->Enable(Sync());
 
   GURL url = GetPageUrl(devtools_client_.get());
 
@@ -148,6 +150,70 @@ void HeadlessRenderTest::OnFrameNavigated(
   frames_[params.GetFrame()->GetId()].push_back(params.GetFrame()->Clone());
 }
 
+void HeadlessRenderTest::OnConsoleAPICalled(
+    const runtime::ConsoleAPICalledParams& params) {
+  std::stringstream str;
+  switch (params.GetType()) {
+    case runtime::ConsoleAPICalledType::WARNING:
+      str << "W";
+      break;
+    case runtime::ConsoleAPICalledType::ASSERT:
+    case runtime::ConsoleAPICalledType::ERR:
+      str << "E";
+      break;
+    case runtime::ConsoleAPICalledType::DEBUG:
+      str << "D";
+      break;
+    case runtime::ConsoleAPICalledType::INFO:
+      str << "I";
+      break;
+    default:
+      str << "L";
+      break;
+  }
+  const auto& args = *params.GetArgs();
+  for (const auto& arg : args) {
+    str << " ";
+    if (arg->HasDescription()) {
+      str << arg->GetDescription();
+    } else if (arg->GetType() == runtime::RemoteObjectType::UNDEFINED) {
+      str << "undefined";
+    } else if (arg->HasValue()) {
+      const base::Value* v = arg->GetValue();
+      switch (v->type()) {
+        case base::Value::Type::NONE:
+          str << "null";
+          break;
+        case base::Value::Type::BOOLEAN:
+          str << v->GetBool();
+          break;
+        case base::Value::Type::INTEGER:
+          str << v->GetInt();
+          break;
+        case base::Value::Type::DOUBLE:
+          str << v->GetDouble();
+          break;
+        case base::Value::Type::STRING:
+          str << v->GetString();
+          break;
+        default:
+          DCHECK(false);
+          break;
+      }
+    } else {
+      DCHECK(false);
+    }
+  }
+  console_log_.push_back(str.str());
+}
+
+void HeadlessRenderTest::OnExceptionThrown(
+    const runtime::ExceptionThrownParams& params) {
+  const runtime::ExceptionDetails* details = params.GetExceptionDetails();
+  js_exceptions_.push_back(details->GetText() + " " +
+                           details->GetException()->GetDescription());
+}
+
 void HeadlessRenderTest::OnRequest(const GURL& url,
                                    base::Closure complete_request) {
   complete_request.Run();
@@ -177,15 +243,24 @@ void HeadlessRenderTest::OnGetDomSnapshotDone(
     std::unique_ptr<dom_snapshot::GetSnapshotResult> result) {
   CHECK_EQ(DONE, state_);
   state_ = FINISHED;
+  CleanUp();
   FinishAsynchronousTest();
   VerifyDom(result.get());
 }
 
 void HeadlessRenderTest::HandleTimeout() {
   if (state_ != FINISHED) {
+    CleanUp();
     FinishAsynchronousTest();
     OnTimeout();
   }
 }
 
+void HeadlessRenderTest::CleanUp() {
+  devtools_client_->GetRuntime()->Disable(Sync());
+  devtools_client_->GetRuntime()->GetExperimental()->RemoveObserver(this);
+  devtools_client_->GetPage()->Disable(Sync());
+  devtools_client_->GetPage()->GetExperimental()->RemoveObserver(this);
+}
+
 }  // namespace headless

headless/test/headless_render_test.h

@@ -11,6 +11,7 @@
 #include "base/macros.h"
 #include "headless/public/devtools/domains/emulation.h"
 #include "headless/public/devtools/domains/page.h"
+#include "headless/public/devtools/domains/runtime.h"
 #include "headless/public/headless_browser.h"
 #include "headless/public/headless_browser_context.h"
 #include "headless/public/util/testing/test_in_memory_protocol_handler.h"
@@ -32,6 +33,7 @@ class GetSnapshotResult;
 class HeadlessRenderTest : public HeadlessAsyncDevTooledBrowserTest,
                            public HeadlessBrowserContext::Observer,
                            public page::ExperimentalObserver,
+                           public runtime::ExperimentalObserver,
                            public TestInMemoryProtocolHandler::RequestDeferrer {
  public:
   typedef std::pair<std::string, page::FrameScheduledNavigationReason> Redirect;
@@ -100,6 +102,11 @@ class HeadlessRenderTest : public HeadlessAsyncDevTooledBrowserTest,
       const page::FrameClearedScheduledNavigationParams& params) override;
   void OnFrameNavigated(const page::FrameNavigatedParams& params) override;
 
+  // runtime::ExperimentalObserver implementation:
+  void OnConsoleAPICalled(
+      const runtime::ConsoleAPICalledParams& params) override;
+  void OnExceptionThrown(const runtime::ExceptionThrownParams& params) override;
+
   // TestInMemoryProtocolHandler::RequestDeferrer
   void OnRequest(const GURL& url, base::Closure complete_request) override;
 
@@ -107,12 +114,15 @@ class HeadlessRenderTest : public HeadlessAsyncDevTooledBrowserTest,
   std::map<std::string, Redirect> unconfirmed_frame_redirects_;
   std::map<std::string, std::vector<std::unique_ptr<page::Frame>>> frames_;
   std::string main_frame_;
+  std::vector<std::string> console_log_;
+  std::vector<std::string> js_exceptions_;
 
  private:
   void HandleVirtualTimeExhausted();
   void OnGetDomSnapshotDone(
       std::unique_ptr<dom_snapshot::GetSnapshotResult> result);
   void HandleTimeout();
+  void CleanUp();
 
   enum State {
     INIT,       // Setting up the client, no navigation performed yet.