Add more options to --screen-config flag.

ui/display/fake_display_delegate.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_delegate.h"
 
+#include <inttypes.h>

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

i was going to suggest including base/format_macros.h (which will also pull in
inttypes.h) instead, since i think it's a bit more cross-platform-friendly
(perhaps not that it matters here), but it looks like it and inttypes.h are
neck-and-neck in terms of usage, so fine to leave like this :-)

+
 #include <string>
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/hash.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/string_split.h"
 #include "base/strings/stringprintf.h"
 #include "ui/display/display.h"
@@ skipping 23 matching lines @@
   if (next_display_id_ == 0xFF) {
     LOG(ERROR) << "Exceeded display id limit";
     return Display::kInvalidDisplayID;
   }
 
   int64_t id = GenerateDisplayID(kReservedManufacturerID, kProductCodeHash,
                                  ++next_display_id_);
 
   FakeDisplaySnapshot::Builder builder;
   builder.SetId(id).SetNativeMode(display_size);
-  builder.SetName(base::StringPrintf("Fake Display %d", next_display_id_));
+  builder.SetName(base::StringPrintf("Fake Display %" PRId64, id));
 
   // Add the first display as internal.
   if (displays_.empty())
     builder.SetType(ui::DISPLAY_CONNECTION_TYPE_INTERNAL);
 
   return AddDisplay(builder.Build()) ? id : Display::kInvalidDisplayID;
 }
 
 bool FakeDisplayDelegate::AddDisplay(
     std::unique_ptr<ui::DisplaySnapshot> display) {
@@ skipping 66 matching lines @@
   callback.Run(displays);
 }
 
 void FakeDisplayDelegate::AddMode(const ui::DisplaySnapshot& output,
                                   const ui::DisplayMode* mode) {}
 
 void FakeDisplayDelegate::Configure(const ui::DisplaySnapshot& output,
                                     const ui::DisplayMode* mode,
                                     const gfx::Point& origin,
                                     const ui::ConfigureCallback& callback) {
-  callback.Run(true);
+  // Check the display mode is appropriate for the display snapshot.
+  for (const auto& existing_mode : output.modes()) {
+    if (existing_mode.get() == mode) {
+      callback.Run(true);
+      return;
+    }
+  }
+
+  callback.Run(false);
 }
 
 void FakeDisplayDelegate::CreateFrameBuffer(const gfx::Size& size) {}
 
 void FakeDisplayDelegate::GetHDCPState(
     const ui::DisplaySnapshot& output,
     const ui::GetHDCPStateCallback& callback) {
   callback.Run(false, ui::HDCP_STATE_UNDESIRED);
 }
 
@@ skipping 44 matching lines @@
   const std::string command_string =
       command_line->GetSwitchValueASCII(switches::kScreenConfig);
 
   // Start without any displays.
   if (command_string == "none")
     return true;
 
   // Split on commas and parse each display string.
   for (std::string part : base::SplitString(
            command_string, ",", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL)) {
+    int64_t id = GenerateDisplayID(kReservedManufacturerID, kProductCodeHash,
+                                   next_display_id_);
     std::unique_ptr<ui::DisplaySnapshot> snapshot =
-        CreateSnapshotFromSpec(part);
+        FakeDisplaySnapshot::CreateFromSpec(id, part);
     if (snapshot) {
       AddDisplay(std::move(snapshot));
+      next_display_id_++;
     } else {
       LOG(ERROR) << "Failed to parse display \"" << part << "\"";
     }
   }
 
   return true;
 }
 
-std::unique_ptr<ui::DisplaySnapshot>
-FakeDisplayDelegate::CreateSnapshotFromSpec(const std::string& spec) {
-  int width = 0;
-  int height = 0;
-  int dpi = 0;
-
-  // Width and height are required but DPI is optional.
-  int found = sscanf(spec.c_str(), "%dx%d^%d", &width, &height, &dpi);
-  if (found < 2)
-    return nullptr;
-
-  int64_t id = GenerateDisplayID(kReservedManufacturerID, kProductCodeHash,
-                                 ++next_display_id_);
-
-  FakeDisplaySnapshot::Builder builder;
-  builder.SetId(id).SetNativeMode(gfx::Size(width, height));
-  builder.SetName(base::StringPrintf("Fake Display %d", next_display_id_));
-
-  if (found >= 3)
-    builder.SetDPI(dpi);
-
-  // TODO(kylechar): Add type to the spec string.
-  if (displays_.empty())
-    builder.SetType(ui::DISPLAY_CONNECTION_TYPE_INTERNAL);
-
-  return builder.Build();
-}
-
 void FakeDisplayDelegate::OnConfigurationChanged() {
   if (!initialized_)
     return;
 
   FOR_EACH_OBSERVER(ui::NativeDisplayObserver, observers_,
                     OnConfigurationChanged());
 }
 
 }  // namespace display