Headless: make URLRequestDispatcher aware of navigations

headless/app/headless_shell.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 <sstream>
 #include <string>
 
 #include "base/base64.h"
 #include "base/bind.h"
@@ skipping 11 matching lines @@
 #include "headless/public/devtools/domains/emulation.h"
 #include "headless/public/devtools/domains/inspector.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_devtools_client.h"
 #include "headless/public/headless_devtools_target.h"
 #include "headless/public/headless_web_contents.h"
 #include "headless/public/util/deterministic_dispatcher.h"
 #include "headless/public/util/deterministic_http_protocol_handler.h"
+#include "headless/public/util/navigation_request.h"
 #include "net/base/file_stream.h"
 #include "net/base/io_buffer.h"
 #include "net/base/ip_address.h"
 #include "net/base/net_errors.h"
 #include "ui/gfx/geometry/size.h"
 
 namespace headless {
+class HeadlessShell;
+
 namespace {
 // Address where to listen to incoming DevTools connections.
 const char kDevToolsHttpServerAddress[] = "127.0.0.1";
 // Default file name for screenshot. Can be overriden by "--screenshot" switch.
 const char kDefaultScreenshotFileName[] = "screenshot.png";
 
 bool ParseWindowSize(std::string window_size, gfx::Size* parsed_window_size) {
   int width, height = 0;
   if (sscanf(window_size.c_str(), "%d%*[x,]%d", &width, &height) >= 2 &&
       width >= 0 && height >= 0) {
     parsed_window_size->set_width(width);
     parsed_window_size->set_height(height);
     return true;
   }
   return false;
 }
 }  // namespace
 
+// Used in deterministic mode to make sure navigations and resource requests
+// complete in the order requested.
+class SimpleNavigationRequest : public NavigationRequest {

[Sami, 2017/02/09 14:05:11]

s/Simple/Shell/? Not sure what a complex navigation request would be :)

Also would you mind moving this to a new file? It's now kind of awkwardly
sandwiched around HeadlessShell.

[alex clarke (OOO till 29th), 2017/02/09 15:08:32]

Done.

+ public:
+  SimpleNavigationRequest(base::WeakPtr<HeadlessShell> headless_shell,
+                          const page::NavigationRequestedParams& params)
+      : headless_shell_(headless_shell),
+        navigation_id_(params.GetNavigationId()) {}
+
+  ~SimpleNavigationRequest() override {}
+
+  void StartProcessing(base::Closure done_callback) override;
+
+  // Note the navigation likely isn't done when this is called, however we
+  // expect it will have been committed and the initial resource load requested.
+  static void ProcessNavigationResult(
+      base::Closure done_callback,
+      std::unique_ptr<page::ProcessNavigationResult>) {
+    done_callback.Run();
+  }
+
+ private:
+  base::WeakPtr<HeadlessShell> headless_shell_;
+  int navigation_id_;
+};
+
 // An application which implements a simple headless browser.
 class HeadlessShell : public HeadlessWebContents::Observer,
                       emulation::ExperimentalObserver,
                       inspector::ExperimentalObserver,
-                      page::Observer {
+                      page::ExperimentalObserver {
  public:
   HeadlessShell()
       : browser_(nullptr),
         devtools_client_(HeadlessDevToolsClient::Create()),
         web_contents_(nullptr),
         processed_page_ready_(false),
         browser_context_(nullptr),
         weak_factory_(this) {}
   ~HeadlessShell() override {}
 
@@ skipping 47 matching lines @@
       }
     }
   }
 
   void Shutdown() {
     if (!web_contents_)
       return;
     if (!RemoteDebuggingEnabled()) {
       devtools_client_->GetEmulation()->GetExperimental()->RemoveObserver(this);
       devtools_client_->GetInspector()->GetExperimental()->RemoveObserver(this);
-      devtools_client_->GetPage()->RemoveObserver(this);
+      devtools_client_->GetPage()->GetExperimental()->RemoveObserver(this);
       if (web_contents_->GetDevToolsTarget()) {
         web_contents_->GetDevToolsTarget()->DetachClient(
             devtools_client_.get());
       }
     }
     web_contents_->RemoveObserver(this);
     web_contents_ = nullptr;
     browser_context_->Close();
     browser_->Shutdown();
   }
 
   // HeadlessWebContents::Observer implementation:
   void DevToolsTargetReady() override {
     web_contents_->GetDevToolsTarget()->AttachClient(devtools_client_.get());
     devtools_client_->GetInspector()->GetExperimental()->AddObserver(this);
-    devtools_client_->GetPage()->AddObserver(this);
+    devtools_client_->GetPage()->GetExperimental()->AddObserver(this);
     devtools_client_->GetPage()->Enable();
     // Check if the document had already finished loading by the time we
     // attached.
 
     devtools_client_->GetEmulation()->GetExperimental()->AddObserver(this);
 
     if (base::CommandLine::ForCurrentProcess()->HasSwitch(
+            switches::kDeterministicFetch)) {
+      devtools_client_->GetPage()->GetExperimental()->SetControlNavigations(
+          headless::page::SetControlNavigationsParams::Builder()
+              .SetEnabled(true)
+              .Build());
+    }
+
+    if (base::CommandLine::ForCurrentProcess()->HasSwitch(
             switches::kVirtualTimeBudget)) {
       std::string budget_ms_ascii =
           base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
               switches::kVirtualTimeBudget);
       int budget_ms;
       CHECK(base::StringToInt(budget_ms_ascii, &budget_ms))
           << "Expected an integer value for --virtual-time-budget=";
       devtools_client_->GetEmulation()->GetExperimental()->SetVirtualTimePolicy(
           emulation::SetVirtualTimePolicyParams::Builder()
               .SetPolicy(emulation::VirtualTimePolicy::
@@ skipping 65 matching lines @@
 
   // page::Observer implementation:
   void OnLoadEventFired(const page::LoadEventFiredParams& params) override {
     if (base::CommandLine::ForCurrentProcess()->HasSwitch(
             switches::kVirtualTimeBudget)) {
       return;
     }
     OnPageReady();
   }
 
+  void OnNavigationRequested(
+      const headless::page::NavigationRequestedParams& params) override {
+    deterministic_dispatcher_->NavigationRequested(
+        base::MakeUnique<SimpleNavigationRequest>(weak_factory_.GetWeakPtr(),
+                                                  params));
+  }
+
   void OnPageReady() {
     if (processed_page_ready_)
       return;
     processed_page_ready_ = true;
 
     if (base::CommandLine::ForCurrentProcess()->HasSwitch(switches::kDumpDom)) {
       FetchDom();
     } else if (base::CommandLine::ForCurrentProcess()->HasSwitch(
                    switches::kRepl)) {
       LOG(INFO)
@@ skipping 131 matching lines @@
   }
 
   void OnScreenshotFileClosed(const int close_result) { Shutdown(); }
 
   bool RemoteDebuggingEnabled() const {
     const base::CommandLine& command_line =
         *base::CommandLine::ForCurrentProcess();
     return command_line.HasSwitch(switches::kRemoteDebuggingPort);
   }
 
+  HeadlessDevToolsClient* devtools_client() const {
+    return devtools_client_.get();
+  }
+
  private:
   GURL url_;
   HeadlessBrowser* browser_;  // Not owned.
   std::unique_ptr<HeadlessDevToolsClient> devtools_client_;
   HeadlessWebContents* web_contents_;
   bool processed_page_ready_;
   std::unique_ptr<net::FileStream> screenshot_file_stream_;
   HeadlessBrowserContext* browser_context_;
   std::unique_ptr<DeterministicDispatcher> deterministic_dispatcher_;
   base::WeakPtrFactory<HeadlessShell> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(HeadlessShell);
 };
 
+void SimpleNavigationRequest::StartProcessing(base::Closure done_callback) {
+  if (!headless_shell_)
+    return;
+
+  // Allow the navigation to proceed.
+  headless_shell_->devtools_client()
+      ->GetPage()
+      ->GetExperimental()
+      ->ProcessNavigation(
+          headless::page::ProcessNavigationParams::Builder()
+              .SetNavigationId(navigation_id_)
+              .SetResponse(headless::page::NavigationResponse::PROCEED)
+              .Build(),
+          base::Bind(&SimpleNavigationRequest::ProcessNavigationResult,
+                     done_callback));
+}
+
 bool ValidateCommandLine(const base::CommandLine& command_line) {
   if (!command_line.HasSwitch(switches::kRemoteDebuggingPort)) {
     if (command_line.GetArgs().size() <= 1)
       return true;
     LOG(ERROR) << "Open multiple tabs is only supported when the "
                << "remote debug port is set.";
     return false;
   }
   if (command_line.HasSwitch(switches::kDumpDom)) {
     LOG(ERROR) << "Dump DOM is disabled when remote debugging is enabled.";
@@ skipping 103 matching lines @@
     builder.SetOverrideWebPreferencesCallback(base::Bind([](
         WebPreferences* preferences) { preferences->hide_scrollbars = true; }));
   }
 
   return HeadlessBrowserMain(
       builder.Build(),
       base::Bind(&HeadlessShell::OnStart, base::Unretained(&shell)));
 }
 
 }  // namespace headless