[ChromeDriver][PageLifecycle] Add support for freeze/resume in ChromeDriver

The CL maps the Page.setWebLifecycleState devtools
protocol method to httphandler endpoints.

Change-Id: I1eb66cb3e6c73b55949974fc572456c81ffaeed6

Bug: chromium:837709
Change-Id: I1eb66cb3e6c73b55949974fc572456c81ffaeed6
Reviewed-on: https://chromium-review.googlesource.com/1066395
Commit-Queue: Fadi Meawad <fmeawad@chromium.org>
Reviewed-by: Jonathon Kereliuk <kereliuk@chromium.org>
Cr-Commit-Position: refs/heads/master@{#565428}

chrome/test/chromedriver/BUILD.gn

@@ -388,6 +388,7 @@ test("chromedriver_unittests") {
     "session_commands_unittest.cc",
     "session_unittest.cc",
     "util_unittest.cc",
+    "window_commands_unittest.cc",
   ]
 
   # TODO(jschuh): crbug.com/167187 fix size_t to int truncations.

chrome/test/chromedriver/chrome/stub_web_view.cc

@@ -40,6 +40,14 @@ Status StubWebView::Reload(const Timeout* timeout) {
   return Status(kOk);
 }
 
+Status StubWebView::Freeze(const Timeout* timeout) {
+  return Status(kOk);
+}
+
+Status StubWebView::Resume(const Timeout* timeout) {
+  return Status(kOk);
+}
+
 Status StubWebView::SendCommand(const std::string& cmd,
                                 const base::DictionaryValue& params) {
   return Status(kOk);

chrome/test/chromedriver/chrome/stub_web_view.h

@@ -25,6 +25,8 @@ class StubWebView : public WebView {
   Status GetUrl(std::string* url) override;
   Status Load(const std::string& url, const Timeout* timeout) override;
   Status Reload(const Timeout* timeout) override;
+  Status Freeze(const Timeout* timeout) override;
+  Status Resume(const Timeout* timeout) override;
   Status SendCommand(const std::string& cmd,
                      const base::DictionaryValue& params) override;
   Status SendCommandAndGetResult(const std::string& cmd,

chrome/test/chromedriver/chrome/web_view.h

@@ -54,6 +54,12 @@ class WebView {
   // Reload the current page.
   virtual Status Reload(const Timeout* timeout) = 0;
 
+  // Freeze the current page.
+  virtual Status Freeze(const Timeout* timeout) = 0;
+
+  // Resume the current page.
+  virtual Status Resume(const Timeout* timeout) = 0;
+
   // Send a command to the DevTools debugger
   virtual Status SendCommand(const std::string& cmd,
                              const base::DictionaryValue& params) = 0;

chrome/test/chromedriver/chrome/web_view_impl.cc

@@ -231,6 +231,20 @@ Status WebViewImpl::Reload(const Timeout* timeout) {
   return client_->SendCommandWithTimeout("Page.reload", params, timeout);
 }
 
+Status WebViewImpl::Freeze(const Timeout* timeout) {
+  base::DictionaryValue params;
+  params.SetString("state", "frozen");
+  return client_->SendCommandWithTimeout("Page.setWebLifecycleState", params,
+                                         timeout);
+}
+
+Status WebViewImpl::Resume(const Timeout* timeout) {
+  base::DictionaryValue params;
+  params.SetString("state", "active");
+  return client_->SendCommandWithTimeout("Page.setWebLifecycleState", params,
+                                         timeout);
+}
+
 Status WebViewImpl::SendCommand(const std::string& cmd,
                                 const base::DictionaryValue& params) {
   return client_->SendCommand(cmd, params);

chrome/test/chromedriver/chrome/web_view_impl.h

@@ -54,6 +54,8 @@ class WebViewImpl : public WebView {
   Status GetUrl(std::string* url) override;
   Status Load(const std::string& url, const Timeout* timeout) override;
   Status Reload(const Timeout* timeout) override;
+  Status Freeze(const Timeout* timeout) override;
+  Status Resume(const Timeout* timeout) override;
   Status SendCommand(const std::string& cmd,
                      const base::DictionaryValue& params) override;
   Status SendCommandAndGetResult(const std::string& cmd,

chrome/test/chromedriver/server/http_handler.cc

@@ -113,6 +113,10 @@ HttpHandler::HttpHandler(
 
       CommandMapping(kPost, "session/:sessionId/refresh",
                      WrapToCommand("Refresh", base::Bind(&ExecuteRefresh))),
+      CommandMapping(kPost, "session/:sessionId/goog/page/freeze",
+                     WrapToCommand("Freeze", base::Bind(&ExecuteFreeze))),
+      CommandMapping(kPost, "session/:sessionId/goog/page/resume",
+                     WrapToCommand("Resume", base::Bind(&ExecuteResume))),
       CommandMapping(kGet, "session/:sessionId/title",
                      WrapToCommand("GetTitle", base::Bind(&ExecuteGetTitle))),
       CommandMapping(kGet, "session/:sessionId/window",

chrome/test/chromedriver/window_commands.cc

@@ -558,6 +558,28 @@ Status ExecuteRefresh(Session* session,
   return Status(kOk);
 }
 
+Status ExecuteFreeze(Session* session,
+                     WebView* web_view,
+                     const base::DictionaryValue& params,
+                     std::unique_ptr<base::Value>* value,
+                     Timeout* timeout) {
+  timeout->SetDuration(session->page_load_timeout);
+  Status status = web_view->Freeze(timeout);
+  return status;
+}
+
+Status ExecuteResume(Session* session,
+                     WebView* web_view,
+                     const base::DictionaryValue& params,
+                     std::unique_ptr<base::Value>* value,
+                     Timeout* timeout) {
+  timeout->SetDuration(session->page_load_timeout);
+  Status status = web_view->Resume(timeout);
+  if (status.IsError())
+    return status;
+  return Status(kOk);
+}
+
 Status ExecuteMouseMoveTo(Session* session,
                           WebView* web_view,
                           const base::DictionaryValue& params,

chrome/test/chromedriver/window_commands.h

@@ -127,6 +127,20 @@ Status ExecuteRefresh(Session* session,
                       std::unique_ptr<base::Value>* value,
                       Timeout* timeout);
 
+// Freeze the current page.
+Status ExecuteFreeze(Session* session,
+                     WebView* web_view,
+                     const base::DictionaryValue& params,
+                     std::unique_ptr<base::Value>* value,
+                     Timeout* timeout);
+
+// Resume the current page.
+Status ExecuteResume(Session* session,
+                     WebView* web_view,
+                     const base::DictionaryValue& params,
+                     std::unique_ptr<base::Value>* value,
+                     Timeout* timeout);
+
 // Move the mouse by an offset of the element if specified .
 Status ExecuteMouseMoveTo(Session* session,
                           WebView* web_view,

chrome/test/chromedriver/window_commands_unittest.cc

+// Copyright (c) 2013 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/values.h"
+#include "chrome/test/chromedriver/chrome/status.h"
+#include "chrome/test/chromedriver/chrome/stub_chrome.h"
+#include "chrome/test/chromedriver/chrome/stub_web_view.h"
+#include "chrome/test/chromedriver/commands.h"
+#include "chrome/test/chromedriver/net/timeout.h"
+#include "chrome/test/chromedriver/session.h"
+#include "chrome/test/chromedriver/window_commands.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace {
+
+class MockChrome : public StubChrome {
+ public:
+  MockChrome() : web_view_("1") {}
+  ~MockChrome() override {}
+
+  Status GetWebViewById(const std::string& id, WebView** web_view) override {
+    if (id == web_view_.GetId()) {
+      *web_view = &web_view_;
+      return Status(kOk);
+    }
+    return Status(kUnknownError);
+  }
+
+ private:
+  // Using a StubWebView does not allow testing the functionality end-to-end,
+  // more details in crbug.com/850703
+  StubWebView web_view_;
+};
+
+}  // namespace
+
+TEST(WindowCommandsTest, ExecuteFreeze) {
+  MockChrome* chrome = new MockChrome();
+  Session session("id", std::unique_ptr<Chrome>(chrome));
+  base::DictionaryValue params;
+  std::unique_ptr<base::Value> value;
+  Timeout timeout;
+
+  WebView* web_view = NULL;
+  Status status = chrome->GetWebViewById("1", &web_view);
+  ASSERT_EQ(kOk, status.code());
+  status = ExecuteFreeze(&session, web_view, params, &value, &timeout);
+}
+
+TEST(WindowCommandsTest, ExecuteResume) {
+  MockChrome* chrome = new MockChrome();
+  Session session("id", std::unique_ptr<Chrome>(chrome));
+  base::DictionaryValue params;
+  std::unique_ptr<base::Value> value;
+  Timeout timeout;
+
+  WebView* web_view = NULL;
+  Status status = chrome->GetWebViewById("1", &web_view);
+  ASSERT_EQ(kOk, status.code());
+  status = ExecuteResume(&session, web_view, params, &value, &timeout);
+}