Add more options to --screen-config flag.

ui/display/fake_display_snapshot.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 "ui/display/fake_display_snapshot.h"
 
 #include <inttypes.h>
 
 #include <sstream>
 #include <utility>
 #include <vector>
 
 #include "base/memory/ptr_util.h"
+#include "base/strings/string_number_conversions.h"
+#include "base/strings/string_split.h"
 #include "base/strings/stringprintf.h"
+#include "third_party/re2/src/re2/re2.h"
+
+using base::StringPiece;
 
 namespace display {
 
 namespace {
 
 static const float kInchInMm = 25.4f;
 
 // Get pixel pitch in millimeters from DPI.
 float PixelPitchMmFromDPI(float dpi) {
   return (1.0f / dpi) * kInchInMm;
@@ skipping 30 matching lines @@
       return "dp";
     case ui::DISPLAY_CONNECTION_TYPE_NETWORK:
       return "network";
     case ui::DISPLAY_CONNECTION_TYPE_VIRTUAL:
       return "virtual";
   }
   NOTREACHED();
   return "";
 }
 
+// Extracts text after specified delimiter. If the delimiter doesn't exist then

[Daniel Erat, 2016/10/07 17:17:22]

nit: "If the delimiter doesn't appear exactly once ..."?

[kylechar, 2016/10/11 13:56:49]

Done.

+// the result will be empty and the input string will be unmodified. Otherwise,
+// the input string will contain the text before the delimiter and the result
+// will be the text after the delimiter.
+StringPiece ExtractSuffix(StringPiece* str, StringPiece delimiter) {
+  std::vector<StringPiece> parts = base::SplitStringPiece(
+      *str, delimiter, base::TRIM_WHITESPACE, base::SPLIT_WANT_NONEMPTY);
+
+  if (parts.size() == 2) {
+    *str = parts[0];
+    return parts[1];
+  }
+
+  return StringPiece();
+}
+
+// Parses a display mode from |str| in the format HxW[%R], returning null if
+// |str| is invalid.
+std::unique_ptr<ui::DisplayMode> ParseDisplayMode(const std::string& str) {
+  int width = 0;
+  int height = 0;
+  float refresh_rate = 60.0f;
+
+  // With sscanf() it will happily ignore characters at the end of the string,
+  // so check |str| is valid using a regex.
+  if (!RE2::FullMatch(str, "\\d+x\\d+(?:%\\d+(?:\\.\\d*)?)?")) {

[Daniel Erat, 2016/10/07 17:17:22]

since you're already using a regexp, why not extract sub-patterns into variables
here instead of using sscanf() for that? if i'm reading re2.h correctly (search
for "CAVEAT"), the optional refresh rate needs to be extracted to a string
(which will be empty if it's not present).

[kylechar, 2016/10/11 13:56:49]

For the caveat I don't think it applies to the regex in this patch. The (:?) is
a non-capture group so it's just used for matching. That caveat seems like it
would make it impossible to use re2 to extract an optional float value? However,
I just tried it out and it works fine for me. So I've removed the sscanf bit.

+    LOG(ERROR) << "Invalid display mode string \"" << str << "\"";
+    return nullptr;
+  }
+
+  // Refresh rate is optional and will be be 60 if not specified.
+  if (sscanf(str.c_str(), "%dx%d%%%f", &width, &height, &refresh_rate) < 2) {
+    LOG(ERROR) << "Unable to parse display mode \"" << str << "\"";
+    return nullptr;
+  }
+
+  return base::MakeUnique<ui::DisplayMode>(gfx::Size(width, height), false,
+                                           refresh_rate);
+}
+
+// Parses a list of alternate display modes, adding each new display mode to
+// |builder|. Returns false if any of the modes are invalid.
+bool HandleModes(FakeDisplaySnapshot::Builder* builder,
+                 StringPiece resolutions) {
+  for (const std::string& mode_str :
+       base::SplitString(resolutions, ":", base::TRIM_WHITESPACE,
+                         base::SPLIT_WANT_NONEMPTY)) {
+    std::unique_ptr<ui::DisplayMode> mode = ParseDisplayMode(mode_str);
+    if (!mode)
+      return false;
+
+    builder->AddMode(std::move(mode));
+  }
+
+  return true;
+}
+
+// Parses device DPI and updates |builder|. Returns false if an invalid DPI
+// string is provided.
+bool HandleDPI(FakeDisplaySnapshot::Builder* builder, StringPiece dpi) {
+  if (dpi.empty())
+    return true;
+
+  int dpi_value = 0;
+  if (base::StringToInt(dpi, &dpi_value)) {
+    builder->SetDPI(dpi_value);
+    return true;
+  }
+
+  LOG(ERROR) << "Invalid DPI string \"" << dpi << "\"";
+  return false;
+}
+
+// Parses a list of display options and set each option true on |builder|.
+// Returns false if any invalid options are provided. If an option appears more
+// than once it will have no effect the second time.
+bool HandleOptions(FakeDisplaySnapshot::Builder* builder, StringPiece options) {
+  for (size_t i = 0; i < options.size(); ++i) {
+    switch (options[i]) {
+      case 'o':
+        builder->SetHasOverscan(true);
+        break;
+      case 'c':
+        builder->SetHasColorCorrectionMatrix(true);
+        break;
+      case 'a':
+        builder->SetIsAspectPerservingScaling(true);
+        break;
+      case 'i':
+        builder->SetType(ui::DISPLAY_CONNECTION_TYPE_INTERNAL);
+        break;
+      default:
+        LOG(ERROR) << "Invalid option specifier \"" << options[i] << "\"";
+        return false;
+    }
+  }
+
+  return true;
+}
+
 }  // namespace
 
 using Builder = FakeDisplaySnapshot::Builder;
 
 Builder::Builder() {}
 
 Builder::~Builder() {}
 
 std::unique_ptr<FakeDisplaySnapshot> Builder::Build() {
   if (modes_.empty() || id_ == Display::kInvalidDisplayID) {
     NOTREACHED() << "Display modes or display ID missing";
     return nullptr;
   }
 
   // If there is no native mode set, use the first display mode.
   if (!native_mode_)
     native_mode_ = modes_.back().get();
 
   // Calculate physical size to match set DPI.
   gfx::Size physical_size =
       gfx::ScaleToRoundedSize(native_mode_->size(), PixelPitchMmFromDPI(dpi_));
 
-  return base::WrapUnique(new FakeDisplaySnapshot(
+  return base::MakeUnique<FakeDisplaySnapshot>(
       id_, origin_, physical_size, type_, is_aspect_preserving_scaling_,
       has_overscan_, has_color_correction_matrix_, name_, product_id_,
-      std::move(modes_), current_mode_, native_mode_));
+      std::move(modes_), current_mode_, native_mode_);
 }
 
 Builder& Builder::SetId(int64_t id) {
   id_ = id;
   return *this;
 }
 
 Builder& Builder::SetNativeMode(const gfx::Size& size) {
   native_mode_ = AddOrFindDisplayMode(size);
   return *this;
 }
 
+Builder& Builder::SetNativeMode(std::unique_ptr<ui::DisplayMode> mode) {
+  native_mode_ = AddOrFindDisplayMode(std::move(mode));
+  return *this;
+}
+
 Builder& Builder::SetCurrentMode(const gfx::Size& size) {
   current_mode_ = AddOrFindDisplayMode(size);
   return *this;
 }
 
+Builder& Builder::SetCurrentMode(std::unique_ptr<ui::DisplayMode> mode) {
+  current_mode_ = AddOrFindDisplayMode(std::move(mode));
+  return *this;
+}
+
 Builder& Builder::AddMode(const gfx::Size& size) {
   AddOrFindDisplayMode(size);
   return *this;
 }
 
+Builder& Builder::AddMode(std::unique_ptr<ui::DisplayMode> mode) {
+  AddOrFindDisplayMode(std::move(mode));
+  return *this;
+}
+
 Builder& Builder::SetOrigin(const gfx::Point& origin) {
   origin_ = origin;
   return *this;
 }
 
 Builder& Builder::SetType(ui::DisplayConnectionType type) {
   type_ = type;
   return *this;
 }
 
@@ skipping 39 matching lines @@
   for (auto& mode : modes_) {
     if (mode->size() == size)
       return mode.get();
   }
 
   // Not found, insert a mode with the size and return.
   modes_.push_back(base::MakeUnique<ui::DisplayMode>(size, false, 60.0f));
   return modes_.back().get();
 }
 
-FakeDisplaySnapshot::FakeDisplaySnapshot(
-    int64_t display_id,
-    const gfx::Point& origin,
-    const gfx::Size& physical_size,
-    ui::DisplayConnectionType type,
-    bool is_aspect_preserving_scaling,
-    bool has_overscan,
-    bool has_color_correction_matrix,
-    std::string display_name,
-    int64_t product_id,
-    std::vector<std::unique_ptr<const ui::DisplayMode>> modes,
-    const ui::DisplayMode* current_mode,
-    const ui::DisplayMode* native_mode)
+const ui::DisplayMode* Builder::AddOrFindDisplayMode(
+    std::unique_ptr<ui::DisplayMode> mode) {
+  for (auto& existing : modes_) {
+    if (mode->size() == existing->size() &&
+        mode->is_interlaced() == existing->is_interlaced() &&
+        mode->refresh_rate() == existing->refresh_rate())
+      return existing.get();
+  }
+
+  // Not found, insert mode and return.
+  modes_.push_back(std::move(mode));
+  return modes_.back().get();
+}
+
+FakeDisplaySnapshot::FakeDisplaySnapshot(int64_t display_id,
+                                         const gfx::Point& origin,
+                                         const gfx::Size& physical_size,
+                                         ui::DisplayConnectionType type,
+                                         bool is_aspect_preserving_scaling,
+                                         bool has_overscan,
+                                         bool has_color_correction_matrix,
+                                         std::string display_name,
+                                         int64_t product_id,
+                                         DisplayModeList modes,
+                                         const ui::DisplayMode* current_mode,
+                                         const ui::DisplayMode* native_mode)
     : DisplaySnapshot(display_id,
                       origin,
                       physical_size,
                       type,
                       is_aspect_preserving_scaling,
                       has_overscan,
                       has_color_correction_matrix,
                       display_name,
                       base::FilePath(),
                       std::move(modes),
                       std::vector<uint8_t>(),
                       current_mode,
                       native_mode) {
   product_id_ = product_id;
 }
 
 FakeDisplaySnapshot::~FakeDisplaySnapshot() {}
 
+// static
+std::unique_ptr<ui::DisplaySnapshot> FakeDisplaySnapshot::CreateFromSpec(
+    int64_t id,
+    const std::string& spec) {
+  StringPiece leftover(spec);
+
+  // Cut off end of string at each delimiter to split.
+  StringPiece options = ExtractSuffix(&leftover, "/");
+  StringPiece dpi = ExtractSuffix(&leftover, "^");
+  StringPiece resolutions = ExtractSuffix(&leftover, "#");
+
+  // Leftovers should be just the native mode at this point.
+  std::unique_ptr<ui::DisplayMode> native_mode =
+      ParseDisplayMode(leftover.as_string());
+
+  // Fail without valid native mode.
+  if (!native_mode)
+    return nullptr;
+
+  FakeDisplaySnapshot::Builder builder;
+  builder.SetId(id).SetNativeMode(std::move(native_mode));
+  builder.SetName(base::StringPrintf("Fake Display %" PRId64, id));
+
+  if (!HandleModes(&builder, resolutions) || !HandleDPI(&builder, dpi) ||
+      !HandleOptions(&builder, options))
+    return nullptr;
+
+  return builder.Build();
+}
+
 std::string FakeDisplaySnapshot::ToString() const {
   return base::StringPrintf(
       "id=%" PRId64
       " current_mode=%s native_mode=%s origin=%s"
       " physical_size=%s, type=%s name=\"%s\" modes=(%s)",
       display_id_,
       current_mode_ ? current_mode_->ToString().c_str() : "nullptr",
       native_mode_ ? native_mode_->ToString().c_str() : "nullptr",
       origin_.ToString().c_str(), physical_size_.ToString().c_str(),
       DisplayConnectionTypeString(type_).c_str(), display_name_.c_str(),
       ModeListString(modes_).c_str());
 }
 
 }  // namespace display