[ChromeDriver] Extract ConfigureHeadlessSession

Refactored InitSessionHelper for better test coverage. Extracted
ConfigureHeadlessSession function, and added unit tests.

Bug: chromedriver:3102
Change-Id: I6ac964c923924d8b6205a87710e2468c40acf5fd
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1792796Reviewed-by: John Chen <johnchen@chromium.org>
Commit-Queue: Tricia Crichton <triciac@chromium.org>
Cr-Commit-Position: refs/heads/master@{#694966}

chrome/test/chromedriver/session_commands.cc

@@ -314,24 +314,9 @@ Status InitSessionHelper(const InitSessionParams& bound_params,
   session->capabilities =
       CreateCapabilities(session, capabilities, *desired_caps);
 
-  if (session->chrome->GetBrowserInfo()->is_headless) {
-    std::string download_directory;
-    if (capabilities.prefs &&
-        (capabilities.prefs->GetString("download.default_directory",
-                                       &download_directory) ||
-         capabilities.prefs->GetStringWithoutPathExpansion(
-             "download.default_directory", &download_directory)))
-      session->headless_download_directory =
-          std::make_unique<std::string>(download_directory);
-    else
-      session->headless_download_directory = std::make_unique<std::string>(".");
-    WebView* first_view;
-    session->chrome->GetWebViewById(session->window, &first_view);
-    status = first_view->OverrideDownloadDirectoryIfNeeded(
-        *session->headless_download_directory);
+  status = internal::ConfigureHeadlessSession(session, capabilities);
   if (status.IsError())
     return status;
-  }
 
   if (session->w3c_compliant) {
     std::unique_ptr<base::DictionaryValue> capabilities =
@@ -349,6 +334,33 @@ Status InitSessionHelper(const InitSessionParams& bound_params,
 
 }  // namespace
 
+namespace internal {
+
+Status ConfigureHeadlessSession(Session* session,
+                                const Capabilities& capabilities) {
+  if (session->chrome->GetBrowserInfo()->is_headless) {
+    std::string download_directory;
+    if (capabilities.prefs &&
+        (capabilities.prefs->GetString("download.default_directory",
+                                       &download_directory) ||
+         capabilities.prefs->GetStringWithoutPathExpansion(
+             "download.default_directory", &download_directory)))
+      session->headless_download_directory =
+          std::make_unique<std::string>(download_directory);
+    else
+      session->headless_download_directory = std::make_unique<std::string>(".");
+    WebView* first_view;
+    session->chrome->GetWebViewById(session->window, &first_view);
+    Status status = first_view->OverrideDownloadDirectoryIfNeeded(
+        *session->headless_download_directory);
+    return status;
+  }
+  // session is not headless
+  return Status(kOk);
+}
+
+}  // namespace internal
+
 bool MergeCapabilities(const base::DictionaryValue* always_match,
                        const base::DictionaryValue* first_match,
                        base::DictionaryValue* merged) {

chrome/test/chromedriver/session_commands.h

@@ -18,6 +18,7 @@ class DictionaryValue;
 class Value;
 }
 
+struct Capabilities;
 class DeviceManager;
 struct Session;
 class Status;
@@ -164,4 +165,9 @@ Status ExecuteGenerateTestReport(Session* session,
                                  const base::DictionaryValue& params,
                                  std::unique_ptr<base::Value>* value);
 
+namespace internal {
+Status ConfigureHeadlessSession(Session* session,
+                                const Capabilities& capabilities);
+}  // namespace internal
+
 #endif  // CHROME_TEST_CHROMEDRIVER_SESSION_COMMANDS_H_

chrome/test/chromedriver/session_commands_unittest.cc

@@ -16,8 +16,10 @@
 #include "base/system/sys_info.h"
 #include "base/threading/thread.h"
 #include "base/values.h"
+#include "chrome/test/chromedriver/capabilities.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/session.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ -422,3 +424,116 @@ TEST(SessionCommandsTest, QuitFails) {
   std::unique_ptr<base::Value> value;
   ASSERT_EQ(kUnknownError, ExecuteQuit(false, &session, params, &value).code());
 }
+
+namespace {
+
+class MockChrome : public StubChrome {
+ public:
+  explicit MockChrome(BrowserInfo& binfo) : web_view_("1") {
+    browser_info_ = binfo;
+  }
+  ~MockChrome() override {}
+
+  const BrowserInfo* GetBrowserInfo() const override { return &browser_info_; }
+
+  Status GetWebViewById(const std::string& id, WebView** web_view) override {
+    *web_view = &web_view_;
+    return Status(kOk);
+  }
+
+ private:
+  BrowserInfo browser_info_;
+  StubWebView web_view_;
+};
+
+}  // namespace
+
+TEST(SessionCommandsTest, ConfigureHeadlessSession_dotNotation) {
+  Capabilities capabilities;
+  base::DictionaryValue caps;
+  base::Value::ListStorage args;
+  args.emplace_back("headless");
+  caps.SetPath({"goog:chromeOptions", "args"}, base::Value(args));
+
+  base::DictionaryValue prefs;
+  prefs.SetKey("download.default_directory",
+               base::Value("/examples/python/downloads"));
+  caps.SetPath({"goog:chromeOptions", "prefs"}, prefs.Clone());
+
+  Status status = capabilities.Parse(caps);
+  BrowserInfo binfo;
+  binfo.is_headless = true;
+  MockChrome* chrome = new MockChrome(binfo);
+  Session session("id", std::unique_ptr<Chrome>(chrome));
+
+  status = internal::ConfigureHeadlessSession(&session, capabilities);
+  ASSERT_EQ(kOk, status.code()) << status.message();
+  ASSERT_TRUE(session.chrome->GetBrowserInfo()->is_headless);
+  ASSERT_STREQ("/examples/python/downloads",
+               session.headless_download_directory->c_str());
+}
+
+TEST(SessionCommandsTest, ConfigureHeadlessSession_nestedMap) {
+  Capabilities capabilities;
+  base::DictionaryValue caps;
+  base::Value::ListStorage args;
+  args.emplace_back("headless");
+  caps.SetPath({"goog:chromeOptions", "args"}, base::Value(args));
+
+  base::DictionaryValue prefs;
+  std::unique_ptr<base::DictionaryValue> download(new base::DictionaryValue());
+  download->SetStringPath("default_directory", "/examples/python/downloads");
+  prefs.SetDictionary("download", std::move(download));
+  caps.SetPath({"goog:chromeOptions", "prefs"}, prefs.Clone());
+
+  Status status = capabilities.Parse(caps);
+  BrowserInfo binfo;
+  binfo.is_headless = true;
+  MockChrome* chrome = new MockChrome(binfo);
+  Session session("id", std::unique_ptr<Chrome>(chrome));
+
+  status = internal::ConfigureHeadlessSession(&session, capabilities);
+  ASSERT_EQ(kOk, status.code()) << status.message();
+  ASSERT_TRUE(session.chrome->GetBrowserInfo()->is_headless);
+  ASSERT_STREQ("/examples/python/downloads",
+               session.headless_download_directory->c_str());
+}
+
+TEST(SessionCommandsTest, ConfigureHeadlessSession_noDownloadDir) {
+  Capabilities capabilities;
+  base::DictionaryValue caps;
+  base::Value::ListStorage args;
+  args.emplace_back("headless");
+  caps.SetPath({"goog:chromeOptions", "args"}, base::Value(args));
+
+  Status status = capabilities.Parse(caps);
+  BrowserInfo binfo;
+  binfo.is_headless = true;
+  MockChrome* chrome = new MockChrome(binfo);
+  Session session("id", std::unique_ptr<Chrome>(chrome));
+
+  status = internal::ConfigureHeadlessSession(&session, capabilities);
+  ASSERT_EQ(kOk, status.code()) << status.message();
+  ASSERT_TRUE(session.chrome->GetBrowserInfo()->is_headless);
+  ASSERT_STREQ(".", session.headless_download_directory->c_str());
+}
+
+TEST(SessionCommandsTest, ConfigureHeadlessSession_notHeadless) {
+  Capabilities capabilities;
+  base::DictionaryValue caps;
+  base::DictionaryValue prefs;
+  std::unique_ptr<base::DictionaryValue> download(new base::DictionaryValue());
+  download->SetStringPath("default_directory", "/examples/python/downloads");
+  prefs.SetDictionary("download", std::move(download));
+  caps.SetPath({"goog:chromeOptions", "prefs"}, prefs.Clone());
+
+  Status status = capabilities.Parse(caps);
+  BrowserInfo binfo;
+  MockChrome* chrome = new MockChrome(binfo);
+  Session session("id", std::unique_ptr<Chrome>(chrome));
+
+  status = internal::ConfigureHeadlessSession(&session, capabilities);
+  ASSERT_EQ(kOk, status.code()) << status.message();
+  ASSERT_FALSE(session.chrome->GetBrowserInfo()->is_headless);
+  ASSERT_FALSE(session.headless_download_directory);
+}