[ChromeDriver] Support mobile emulation on desktop Chrome.

chrome/test/chromedriver/capabilities.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 "chrome/test/chromedriver/capabilities.h"
 
 #include <map>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/json/string_escape.h"
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_tokenizer.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/test/chromedriver/chrome/status.h"
 #include "chrome/test/chromedriver/logging.h"
+#include "chrome/test/chromedriver/mobile_device.h"
 #include "net/base/net_util.h"
 
 namespace {
 
 typedef base::Callback<Status(const base::Value&, Capabilities*)> Parser;
 
 Status ParseBoolean(
     bool* to_set,
     const base::Value& option,
     Capabilities* capabilities) {
@@ skipping 45 matching lines @@
 Status IgnoreCapability(const base::Value& option, Capabilities* capabilities) {
   return Status(kOk);
 }
 
 Status ParseLogPath(const base::Value& option, Capabilities* capabilities) {
   if (!option.GetAsString(&capabilities->log_path))
     return Status(kUnknownError, "must be a string");
   return Status(kOk);
 }
 
+Status ParseDeviceName(std::string device_name, Capabilities* capabilities) {
+  scoped_ptr<MobileDevice> device;
+  Status status = FindMobileDevice(device_name, &device);
+  if (status.IsError())
+    return Status(kUnknownError,
+                  "'" + device_name + "' must be a valid device",
+                  status);
+
+  capabilities->device_metrics = device->device_metrics;
+  capabilities->switches.SetUnparsedSwitch(
+      "--user-agent='" + device->user_agent + "'");
+
+  return Status(kOk);
+}
+
+Status ParseMobileEmulation(const base::Value& option,
+                     Capabilities* capabilities) {

[stgao, 2014/05/14 05:10:14]

indent.

[sam.rawlins, 2014/05/16 21:09:38]

Done.

+  const base::DictionaryValue* mobile_emulation;
+  if (!option.GetAsDictionary(&mobile_emulation))
+    return Status(kUnknownError, "'mobileEmulation' must be a dictionary");
+
+  if (mobile_emulation->HasKey("deviceName")) {
+    // Cannot use any other options with deviceName.
+    if (mobile_emulation->size() > 1)
+      return Status(kUnknownError, "'deviceName' must be used alone");
+
+    std::string device_name;
+    if (!mobile_emulation->GetString("deviceName", &device_name))
+      return Status(kUnknownError, "'deviceName' must be a string");
+
+    return ParseDeviceName(device_name, capabilities);
+  }
+
+  if (mobile_emulation->HasKey("deviceMetrics")) {
+    const base::DictionaryValue* metrics;
+    if (!mobile_emulation->GetDictionary("deviceMetrics", &metrics))
+      return Status(kUnknownError, "'deviceMetrics' must be a dictionary");
+
+    int width;
+    int height;
+    double device_scale_factor;
+    if (!metrics->GetInteger("width", &width) ||
+        !metrics->GetInteger("height", &height) ||
+        !metrics->GetDouble("pixelRatio", &device_scale_factor))
+      return Status(kUnknownError, "invalid 'deviceMetrics'");
+    capabilities->device_metrics =
+        DeviceMetrics(width, height, device_scale_factor);
+  }
+
+  if (mobile_emulation->HasKey("userAgent")) {

[stgao, 2014/05/14 05:10:14]

Do we want to support the case that the user provides only one of deviceMetrics
and userAgent?

[sam.rawlins, 2014/05/16 21:09:38]

I think this is fine. The behavior wouldn't be undefined or unexpected. A user
might be confused if they set deviceMetrics without userAgent, and only got the
desktop version of a website. We just have to rely on general web knowledge.

+    std::string user_agent;
+    if (!mobile_emulation->GetString("userAgent", &user_agent))
+      return Status(kUnknownError, "'userAgent' must be a string");
+
+    capabilities->switches.SetUnparsedSwitch(
+        "--user-agent='" + user_agent + "'");
+  }
+
+  return Status(kOk);
+}
+
 Status ParseSwitches(const base::Value& option,
                      Capabilities* capabilities) {
   const base::ListValue* switches_list = NULL;
   if (!option.GetAsList(&switches_list))
     return Status(kUnknownError, "must be a list");
   for (size_t i = 0; i < switches_list->GetSize(); ++i) {
     std::string arg_string;
     if (!switches_list->GetString(i, &arg_string))
       return Status(kUnknownError, "each argument must be a string");
     capabilities->switches.SetUnparsedSwitch(arg_string);
@@ skipping 168 matching lines @@
     parser_map["androidUseRunningApp"] =
         base::Bind(&ParseBoolean, &capabilities->android_use_running_app);
     parser_map["args"] = base::Bind(&ParseSwitches);
     parser_map["loadAsync"] = base::Bind(&IgnoreDeprecatedOption, "loadAsync");
   } else if (is_existing) {
     parser_map["debuggerAddress"] = base::Bind(&ParseUseExistingBrowser);
   } else {
     parser_map["args"] = base::Bind(&ParseSwitches);
     parser_map["binary"] = base::Bind(&ParseFilePath, &capabilities->binary);
     parser_map["detach"] = base::Bind(&ParseBoolean, &capabilities->detach);
+    parser_map["mobileEmulation"] = base::Bind(&ParseMobileEmulation);
     parser_map["excludeSwitches"] = base::Bind(&ParseExcludeSwitches);
     parser_map["extensions"] = base::Bind(&ParseExtensions);
     parser_map["forceDevToolsScreenshot"] = base::Bind(
         &ParseBoolean, &capabilities->force_devtools_screenshot);
     parser_map["loadAsync"] = base::Bind(&IgnoreDeprecatedOption, "loadAsync");
     parser_map["localState"] =
         base::Bind(&ParseDict, &capabilities->local_state);
     parser_map["logPath"] = base::Bind(&ParseLogPath);
     parser_map["minidumpPath"] =
         base::Bind(&ParseString, &capabilities->minidump_path);
@@ skipping 148 matching lines @@
     if (desired_caps.Get(it->first, &capability)) {
       Status status = it->second.Run(*capability, this);
       if (status.IsError()) {
         return Status(
             kUnknownError, "cannot parse capability: " + it->first, status);
       }
     }
   }
   return Status(kOk);
 }